opencode-skills-collection 4.0.54 → 4.0.55

package/bundled-skills/ios-developer/resources/implementation-playbook.md

@@ -0,0 +1,23 @@
+# Native iOS implementation
+
+## Inputs
+
+Xcode/Swift versions, deployment target, project scheme, feature brief and available simulator/device.
+
+## Procedure
+
+1. Reuse the project's state and navigation architecture. Check API availability against the deployment target before adding platform features.
+2. Implement loading, success, failure and cancellation paths. Keep UI state changes on the appropriate actor and credentials in the project's secure storage abstraction.
+3. Build the actual scheme and test navigation, Dynamic Type, VoiceOver labels and interrupted network requests. State separately which checks used a simulator and which used hardware.
+
+## Worked example
+
+Add a document list with retry. Leaving the screen during loading must not update a disposed view; large text must keep the retry action reachable.
+
+## Verification and handoff
+
+Report the actual files or configuration changed, checks performed, observed results and any untested environment. Keep the original inputs and evidence sufficient to reproduce the conclusion.
+
+## Limitations
+
+Simulator success does not verify signing, push delivery, biometrics or App Store acceptance. Do not upload or distribute without authorization.

package/bundled-skills/junta-leiloeiros/scripts/.snyk

@@ -0,0 +1,5 @@
+# Match the supported interpreter used to verify these requirements.
+# Scoped to this manifest; does not change organization-wide settings.
+version: v1.25.1
+language-settings:
+  python: '3.14'

package/bundled-skills/junta-leiloeiros/scripts/requirements.txt

@@ -1,6 +1,8 @@
 # Dependências principais
 httpx>=0.27.0
 beautifulsoup4>=4.12.0
+# Security floor for BeautifulSoup selector parsing (CVE-2026-49477).
+soupsieve>=2.8.4
 lxml>=6.1.0
 
 # API

package/bundled-skills/kpi-dashboard-design/SKILL.md

@@ -251,71 +251,10 @@ Efficiency:
 
 ### SQL for KPI Calculations
 
-```sql
--- Monthly Recurring Revenue (MRR)
-WITH mrr_calculation AS (
-    SELECT
-        DATE_TRUNC('month', billing_date) AS month,
-        SUM(
-            CASE subscription_interval
-                WHEN 'monthly' THEN amount
-                WHEN 'yearly' THEN amount / 12
-                WHEN 'quarterly' THEN amount / 3
-            END
-        ) AS mrr
-    FROM subscriptions
-    WHERE status = 'active'
-    GROUP BY DATE_TRUNC('month', billing_date)
-)
-SELECT
-    month,
-    mrr,
-    LAG(mrr) OVER (ORDER BY month) AS prev_mrr,
-    (mrr - LAG(mrr) OVER (ORDER BY month)) / LAG(mrr) OVER (ORDER BY month) * 100 AS growth_pct
-FROM mrr_calculation;
-
--- Cohort Retention
-WITH cohorts AS (
-    SELECT
-        user_id,
-        DATE_TRUNC('month', created_at) AS cohort_month
-    FROM users
-),
-activity AS (
-    SELECT
-        user_id,
-        DATE_TRUNC('month', event_date) AS activity_month
-    FROM user_events
-    WHERE event_type = 'active_session'
-)
-SELECT
-    c.cohort_month,
-    EXTRACT(MONTH FROM age(a.activity_month, c.cohort_month)) AS months_since_signup,
-    COUNT(DISTINCT a.user_id) AS active_users,
-    COUNT(DISTINCT a.user_id)::FLOAT / COUNT(DISTINCT c.user_id) * 100 AS retention_rate
-FROM cohorts c
-LEFT JOIN activity a ON c.user_id = a.user_id
-    AND a.activity_month >= c.cohort_month
-GROUP BY c.cohort_month, EXTRACT(MONTH FROM age(a.activity_month, c.cohort_month))
-ORDER BY c.cohort_month, months_since_signup;
-
--- Customer Acquisition Cost (CAC)
-SELECT
-    DATE_TRUNC('month', acquired_date) AS month,
-    SUM(marketing_spend) / NULLIF(COUNT(new_customers), 0) AS cac,
-    SUM(marketing_spend) AS total_spend,
-    COUNT(new_customers) AS customers_acquired
-FROM (
-    SELECT
-        DATE_TRUNC('month', u.created_at) AS acquired_date,
-        u.id AS new_customers,
-        m.spend AS marketing_spend
-    FROM users u
-    JOIN marketing_spend m ON DATE_TRUNC('month', u.created_at) = m.month
-    WHERE u.source = 'marketing'
-) acquisition
-GROUP BY DATE_TRUNC('month', acquired_date);
-```
+Use `resources/metric-queries.sql` for executable normalized-input examples. `users` contains one row per customer, `events` contains user/month observations, `spend` contains source spend rows, and `monthly_revenue` contains one reconciled amount per month. Represent months as an integer year × 12 + month − 1 so offsets do not wrap after December.
+
+The queries keep the original cohort denominator, deduplicate activity before counting, aggregate spend before joining customers, and return NULL for undefined growth or acquisition cost. Missing cohort/month combinations need an explicit reporting calendar if zero-activity rows must be displayed. Normalize subscription intervals, currency, refunds and revenue recognition before producing monthly revenue; these examples do not define accounting policy.
+
 
 ### Python Dashboard Code (Streamlit)
 
@@ -327,7 +266,8 @@ import plotly.graph_objects as go
 
 st.set_page_config(page_title="KPI Dashboard", layout="wide")
 
-# Header with date filter
+# Synthetic layout illustration; this is not a connected or filterable dashboard.
+# Header with illustrative date selector
 col1, col2 = st.columns([3, 1])
 with col1:
     st.title("Executive Dashboard")
@@ -363,7 +303,7 @@ col1, col2 = st.columns(2)
 with col1:
     st.subheader("Revenue Trend")
     revenue_data = pd.DataFrame({
-        'Month': pd.date_range('2024-01-01', periods=12, freq='M'),
+        'Month': pd.date_range('2024-01-01', periods=12, freq='ME'),
         'Revenue': [180000, 195000, 210000, 225000, 240000, 255000,
                     270000, 285000, 300000, 315000, 330000, 345000]
     })

package/bundled-skills/kpi-dashboard-design/resources/implementation-playbook.md

@@ -0,0 +1,23 @@
+# KPI dashboard verification
+
+## Inputs
+
+Decision, audience, reporting grain, source tables, metric owner and period definitions.
+
+## Procedure
+
+1. Define each metric's numerator, denominator, exclusions, unit and freshness. Keep cohort size independent from later activity and aggregate spend before joining to customers.
+2. Build a small reconciliation table with hand-calculated results, zero denominators, duplicate events and cohorts older than twelve months.
+3. Connect every card and chart to the selected date range. Distinguish missing data from zero; show whether higher or lower is better and verify drill-down totals.
+
+## Worked example
+
+A cohort has ten customers and four return in month thirteen. Retention is 40% at month 13, not 100% at month 1. Keep that fixture alongside the query.
+
+## Verification and handoff
+
+Report the actual files or configuration changed, checks performed, observed results and any untested environment. Keep the original inputs and evidence sufficient to reproduce the conclusion.
+
+## Limitations
+
+Example dashboards use synthetic data. A visually correct dashboard is not proof that its financial or attribution definitions are valid.

package/bundled-skills/kpi-dashboard-design/resources/metric-queries.sql

@@ -0,0 +1,30 @@
+-- Inputs are normalized month_index integers, one user per id, and spend rows at source grain.
+-- query: retention
+WITH cohort_sizes AS (
+ SELECT cohort_month, COUNT(*) AS cohort_size FROM users GROUP BY cohort_month
+), active AS (
+ SELECT DISTINCT u.cohort_month, e.month_index - u.cohort_month AS month_offset, u.id
+ FROM users u JOIN events e ON e.user_id = u.id
+ WHERE e.month_index >= u.cohort_month
+)
+SELECT a.cohort_month, a.month_offset, COUNT(*) AS active_users,
+       100.0 * COUNT(*) / c.cohort_size AS retention_pct
+FROM active a JOIN cohort_sizes c ON c.cohort_month = a.cohort_month
+GROUP BY a.cohort_month, a.month_offset, c.cohort_size;
+-- query: cac
+WITH spend_by_month AS (
+ SELECT month_index, SUM(amount) AS spend FROM spend GROUP BY month_index
+), acquired AS (
+ SELECT cohort_month AS month_index, COUNT(*) AS customers
+ FROM users WHERE source = 'marketing' GROUP BY cohort_month
+)
+SELECT s.month_index, s.spend, COALESCE(a.customers, 0) AS customers,
+       1.0 * s.spend / NULLIF(a.customers, 0) AS cac
+FROM spend_by_month s LEFT JOIN acquired a ON a.month_index = s.month_index;
+-- query: growth
+WITH previous AS (
+ SELECT month_index, amount, LAG(amount) OVER (ORDER BY month_index) AS previous_amount
+ FROM monthly_revenue
+)
+SELECT month_index, amount, 100.0 * (amount - previous_amount) / NULLIF(previous_amount, 0) AS growth_pct
+FROM previous;

package/bundled-skills/lint-and-validate/SKILL.md

@@ -1,62 +1,34 @@
 ---
 name: lint-and-validate
-description: "MANDATORY: Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free."
+description: "Run configured lint and type checks, distinguish failures from checks that did not run, and report concrete validation results."
 risk: critical
 source: community
 date_added: "2026-02-27"
 ---
 
-# Lint and Validate Skill
+# Lint and Validate
 
-> **MANDATORY:** Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free.
-
-### Procedures by Ecosystem
-
-#### Node.js / TypeScript
-1. **Lint/Fix:** `npm run lint` or `npx eslint "path" --fix`
-2. **Types:** `npx tsc --noEmit`
-3. **Security:** `npm audit --audit-level=high`
-
-#### Python
-1. **Linter (Ruff):** `ruff check "path" --fix` (Fast & Modern)
-2. **Security (Bandit):** `bandit -r "path" -ll`
-3. **Types (MyPy):** `mypy "path"`
-
-## The Quality Loop
-1. **Write/Edit Code**
-2. **Run Audit** for the project's ecosystem:
-   - **Node.js / TypeScript:** `npm run lint && npx tsc --noEmit`
-   - **Python:** `ruff check . --fix && mypy . && bandit -r . -ll`
-3. **Analyze Report:** Check the "FINAL AUDIT REPORT" section.
-4. **Fix & Repeat:** Submitting code with "FINAL AUDIT" failures is NOT allowed.
-
-## Error Handling
-- If `lint` fails: Fix the style or syntax issues immediately.
-- If `tsc` fails: Correct type mismatches before proceeding.
-- If no tool is configured: Check the project root for `.eslintrc`, `tsconfig.json`, `pyproject.toml` and suggest creating one.
-
----
-**Strict Rule:** No code should be committed or reported as "done" without passing these checks.
-
----
+## When to Use
 
-## Scripts
+Use after behavior or configuration changes when a repository has relevant lint or type checks. Read the repository's instructions and package scripts first. Run focused checks during development and the required checks before completion.
 
-| Script | Purpose | Command |
-|--------|---------|---------|
-| `scripts/lint_runner.py` | Unified lint check | `python scripts/lint_runner.py <project_path>` |
-| `scripts/type_coverage.py` | Type coverage analysis | `python scripts/type_coverage.py <project_path>` |
+## Procedure
 
-## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+1. Identify the changed languages, configured commands, and installed tools. Inspect package scripts before executing them: a script named `lint` can modify files or run arbitrary project code.
+2. Run the project's read-only lint/type-check commands. For Node projects, prefer declared scripts such as `npm run lint` and `npm run typecheck`. Do not use `npx` to silently fetch an absent checker.
+3. For Python, use configured, already installed tools such as `ruff check .` or `mypy .`. Do not assume every `pyproject.toml` configures both. Never add `--fix` without inspecting the proposed changes and the task's authorization.
+4. Fix relevant failures without deleting user work, weakening rules, or raising timeouts just to pass. If a required tool is unavailable, report the exact check that did not run.
+5. Report commands, exit results, scope and remaining limitations. Passing lint does not prove the absence of runtime or security defects.
 
 ## Example
 
-**User request:**
+After correcting a TypeScript behavior, inspect `package.json`, run the configured focused regression test, then `npm run lint` and `npm run typecheck` if those scripts exist. If TypeScript is declared but not installed, report the missing local checker; do not substitute a downloaded package or call the result a pass.
+
+## Bundled helpers
 
-> Use @lint-and-validate for this task: MANDATORY: Run appropriate validation tools after EVERY code change.
+- `python scripts/lint_runner.py /absolute/project`: runs a conservative set of candidate checks. Node fallback checkers must exist in local `node_modules/.bin`; Python candidates must be installed. Inspect the project scripts first. A missing command or failing check exits 1; no configured checks or invalid project metadata exits 2. Exit 0 means the invoked checks passed, not that every needed check was discovered. Python detection is heuristic and may suggest unconfigured Ruff/MyPy commands.
+- `python scripts/type_coverage.py /absolute/project`: read-only annotation inventory, despite its retained compatibility filename. Samples at most 30 files per language, skips links and build/dependency directories, and bounds file reads. Python uses AST nodes to avoid double-counting functions. TypeScript reports lexical `: any` occurrences, including possible comments and strings. No quality percentage or pass/fail threshold is inferred. Exit 2 means no applicable files; parse/read errors exit 1.
 
 ## Limitations
-- Use this skill only when the task clearly matches the scope described above.
-- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
-- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
+
+The runner executes trusted project commands, which may mutate files or access the network. It does not install dependencies, detect every monorepo configuration, or replace the project's CI contract. The inventory is a bounded source sample, not semantic type coverage; inferred types, generics, decorator behavior and correctness require the actual type checker. Do not label unrun checks as successful.

package/bundled-skills/lint-and-validate/scripts/lint_runner.py

@@ -7,13 +7,14 @@ Usage:
     python lint_runner.py <project_path>
 
 Supports:
-    - Node.js: npm run lint, npx tsc --noEmit
+    - Node.js: npm run lint, installed local tsc --noEmit
     - Python: ruff check, mypy
 """
 
 import subprocess
 import sys
 import json
+import os
 from pathlib import Path
 from datetime import datetime
 
@@ -44,14 +45,14 @@ def detect_project_type(project_path: Path) -> dict:
             if "lint" in scripts:
                 result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
             elif "eslint" in deps:
-                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
+                result["linters"].append({"name": "eslint", "cmd": [str(project_path / "node_modules" / ".bin" / ("eslint.cmd" if os.name == "nt" else "eslint")), "."]})
 
             # Check for TypeScript
             if "typescript" in deps or (project_path / "tsconfig.json").exists():
-                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
+                result["linters"].append({"name": "tsc", "cmd": [str(project_path / "node_modules" / ".bin" / ("tsc.cmd" if os.name == "nt" else "tsc")), "--noEmit"]})
 
-        except:
-            pass
+        except (OSError, ValueError, TypeError, AttributeError) as error:
+            raise ValueError(f"Cannot inspect package.json: {error}") from error
 
     # Python project
     if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
@@ -111,7 +112,14 @@ def main():
     print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
 
     # Detect project type
-    project_info = detect_project_type(project_path)
+    if not project_path.is_dir():
+        print("Project directory does not exist.", file=sys.stderr)
+        sys.exit(2)
+    try:
+        project_info = detect_project_type(project_path)
+    except ValueError as error:
+        print(str(error), file=sys.stderr)
+        sys.exit(2)
     print(f"Type: {project_info['type']}")
     print(f"Linters: {len(project_info['linters'])}")
     print("-"*60)
@@ -123,11 +131,12 @@ def main():
             "project": str(project_path),
             "type": project_info["type"],
             "checks": [],
-            "passed": True,
+            "passed": False,
+            "status": "not-checked",
             "message": "No linters configured"
         }
         print(json.dumps(output, indent=2))
-        sys.exit(0)
+        sys.exit(2)
 
     # Run each linter
     results = []

package/bundled-skills/lint-and-validate/scripts/type_coverage.py

@@ -1,173 +1,83 @@
 #!/usr/bin/env python3
-"""
-Type Coverage Checker - Measures TypeScript/Python type coverage.
-Identifies untyped functions, any usage, and type safety issues.
-"""
-import sys
-import re
-import subprocess
+"""Bounded annotation inventory, not type coverage or a type-safety verdict."""
+import ast
+import json
+import os
 from pathlib import Path
-
-# Fix Windows console encoding for Unicode output
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
-except AttributeError:
-    pass  # Python < 3.7
-
-def check_typescript_coverage(project_path: Path) -> dict:
-    """Check TypeScript type coverage."""
-    issues = []
-    passed = []
-    stats = {'any_count': 0, 'untyped_functions': 0, 'total_functions': 0}
-
-    ts_files = list(project_path.rglob("*.ts")) + list(project_path.rglob("*.tsx"))
-    ts_files = [f for f in ts_files if 'node_modules' not in str(f) and '.d.ts' not in str(f)]
-
-    if not ts_files:
-        return {'type': 'typescript', 'files': 0, 'passed': [], 'issues': ["[!] No TypeScript files found"], 'stats': stats}
-
-    for file_path in ts_files[:30]:  # Limit
-        try:
-            content = file_path.read_text(encoding='utf-8', errors='ignore')
-
-            # Count 'any' usage
-            any_matches = re.findall(r':\s*any\b', content)
-            stats['any_count'] += len(any_matches)
-
-            # Find functions without return types
-            # function name(params) { - no return type
-            untyped = re.findall(r'function\s+\w+\s*\([^)]*\)\s*{', content)
-            # Arrow functions without types: const fn = (x) => or (x) =>
-            untyped += re.findall(r'=\s*\([^:)]*\)\s*=>', content)
-            stats['untyped_functions'] += len(untyped)
-
-            # Count typed functions
-            typed = re.findall(r'function\s+\w+\s*\([^)]*\)\s*:\s*\w+', content)
-            typed += re.findall(r':\s*\([^)]*\)\s*=>\s*\w+', content)
-            stats['total_functions'] += len(typed) + len(untyped)
-
-        except Exception:
-            continue
-
-    # Analyze results
-    if stats['any_count'] == 0:
-        passed.append("[OK] No 'any' types found")
-    elif stats['any_count'] <= 5:
-        issues.append(f"[!] {stats['any_count']} 'any' types found (acceptable)")
-    else:
-        issues.append(f"[X] {stats['any_count']} 'any' types found (too many)")
-
-    if stats['total_functions'] > 0:
-        typed_ratio = (stats['total_functions'] - stats['untyped_functions']) / stats['total_functions'] * 100
-        if typed_ratio >= 80:
-            passed.append(f"[OK] Type coverage: {typed_ratio:.0f}%")
-        elif typed_ratio >= 50:
-            issues.append(f"[!] Type coverage: {typed_ratio:.0f}% (improve)")
-        else:
-            issues.append(f"[X] Type coverage: {typed_ratio:.0f}% (too low)")
-
-    passed.append(f"[OK] Analyzed {len(ts_files)} TypeScript files")
-
-    return {'type': 'typescript', 'files': len(ts_files), 'passed': passed, 'issues': issues, 'stats': stats}
-
-def check_python_coverage(project_path: Path) -> dict:
-    """Check Python type hints coverage."""
-    issues = []
-    passed = []
-    stats = {'untyped_functions': 0, 'typed_functions': 0, 'any_count': 0}
-
-    py_files = list(project_path.rglob("*.py"))
-    py_files = [f for f in py_files if not any(x in str(f) for x in ['venv', '__pycache__', '.git', 'node_modules'])]
-
-    if not py_files:
-        return {'type': 'python', 'files': 0, 'passed': [], 'issues': ["[!] No Python files found"], 'stats': stats}
-
-    for file_path in py_files[:30]:  # Limit
+import re
+import sys
+import stat
+
+MAX_FILES = 30
+MAX_BYTES = 1_000_000
+SKIP = {'.git', 'node_modules', 'venv', '.venv', '__pycache__', 'dist', 'build'}
+
+
+def source_files(root, suffixes):
+    """Yield a deterministic sample without following directory or file links."""
+    for directory, dirs, files in os.walk(root, followlinks=False):
+        dirs[:] = sorted(name for name in dirs if name not in SKIP and not (Path(directory) / name).is_symlink())
+        for name in sorted(files):
+            path = Path(directory) / name
+            if path.suffix in suffixes and not path.name.endswith('.d.ts') and not path.is_symlink():
+                yield path
+
+
+def inventory(project_path, language):
+    result = {'type': language, 'files': 0, 'sample_limit': MAX_FILES, 'truncated': False, 'errors': [], 'stats': {}}
+    stats = result['stats']
+    stats.update({'functions': 0, 'fully_annotated_functions': 0} if language == 'python' else {'explicit_any_text_matches': 0})
+    for index, path in enumerate(source_files(project_path, {'.py'} if language == 'python' else {'.ts', '.tsx'})):
+        if index == MAX_FILES:
+            result['truncated'] = True
+            break
         try:
-            content = file_path.read_text(encoding='utf-8', errors='ignore')
-
-            # Count Any usage
-            any_matches = re.findall(r':\s*Any\b', content)
-            stats['any_count'] += len(any_matches)
-
-            # Find functions with type hints
-            typed_funcs = re.findall(r'def\s+\w+\s*\([^)]*:[^)]+\)', content)
-            typed_funcs += re.findall(r'def\s+\w+\s*\([^)]*\)\s*->', content)
-            stats['typed_functions'] += len(typed_funcs)
-
-            # Find functions without type hints
-            all_funcs = re.findall(r'def\s+\w+\s*\(', content)
-            stats['untyped_functions'] += len(all_funcs) - len(typed_funcs)
-
-        except Exception:
-            continue
-
-    total = stats['typed_functions'] + stats['untyped_functions']
-
-    if total > 0:
-        typed_ratio = stats['typed_functions'] / total * 100
-        if typed_ratio >= 70:
-            passed.append(f"[OK] Type hints coverage: {typed_ratio:.0f}%")
-        elif typed_ratio >= 40:
-            issues.append(f"[!] Type hints coverage: {typed_ratio:.0f}%")
-        else:
-            issues.append(f"[X] Type hints coverage: {typed_ratio:.0f}% (add type hints)")
-
-    if stats['any_count'] == 0:
-        passed.append("[OK] No 'Any' types found")
-    elif stats['any_count'] <= 3:
-        issues.append(f"[!] {stats['any_count']} 'Any' types found")
-    else:
-        issues.append(f"[X] {stats['any_count']} 'Any' types found")
+            flags = os.O_RDONLY | getattr(os, 'O_NOFOLLOW', 0) | getattr(os, 'O_NONBLOCK', 0)
+            fd = os.open(path, flags)
+            with os.fdopen(fd, 'rb') as handle:
+                if not stat.S_ISREG(os.fstat(handle.fileno()).st_mode):
+                    raise ValueError('source is not a regular file')
+                raw = handle.read(MAX_BYTES + 1)
+            if len(raw) > MAX_BYTES:
+                raise ValueError('source exceeds byte limit')
+            text = raw.decode('utf-8')
+            if language == 'python':
+                tree = ast.parse(text)
+                for node in ast.walk(tree):
+                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        stats['functions'] += 1
+                        args = node.args.posonlyargs + node.args.args + node.args.kwonlyargs
+                        args += [arg for arg in (node.args.vararg, node.args.kwarg) if arg]
+                        annotated = node.returns is not None and all(arg.annotation is not None for arg in args)
+                        stats['fully_annotated_functions'] += int(annotated)
+            else:
+                # This includes comments/string literals and misses inferred/aliased any.
+                stats['explicit_any_text_matches'] += len(re.findall(r':\s*any\b', text))
+            result['files'] += 1
+        except (OSError, UnicodeError, ValueError, SyntaxError) as error:
+            result['errors'].append({'file': str(path.relative_to(project_path)), 'error': str(error)})
+    return result
+
+
+def check_python_coverage(project_path):
+    return inventory(project_path, 'python')
+
+
+def check_typescript_coverage(project_path):
+    return inventory(project_path, 'typescript')
 
-    passed.append(f"[OK] Analyzed {len(py_files)} Python files")
-
-    return {'type': 'python', 'files': len(py_files), 'passed': passed, 'issues': issues, 'stats': stats}
 
 def main():
-    target = sys.argv[1] if len(sys.argv) > 1 else "."
-    project_path = Path(target)
-
-    print("\n" + "=" * 60)
-    print("  TYPE COVERAGE CHECKER")
-    print("=" * 60 + "\n")
-
-    results = []
-
-    # Check TypeScript
-    ts_result = check_typescript_coverage(project_path)
-    if ts_result['files'] > 0:
-        results.append(ts_result)
-
-    # Check Python
-    py_result = check_python_coverage(project_path)
-    if py_result['files'] > 0:
-        results.append(py_result)
-
-    if not results:
-        print("[!] No TypeScript or Python files found.")
-        sys.exit(0)
-
-    # Print results
-    critical_issues = 0
-    for result in results:
-        print(f"\n[{result['type'].upper()}]")
-        print("-" * 40)
-        for item in result['passed']:
-            print(f"  {item}")
-        for item in result['issues']:
-            print(f"  {item}")
-            if item.startswith("[X]"):
-                critical_issues += 1
-
-    print("\n" + "=" * 60)
-    if critical_issues == 0:
-        print("[OK] TYPE COVERAGE: ACCEPTABLE")
-        sys.exit(0)
-    else:
-        print(f"[X] TYPE COVERAGE: {critical_issues} critical issues")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()
+    root = Path(sys.argv[1] if len(sys.argv) > 1 else '.').resolve()
+    if not root.is_dir():
+        print('Project directory does not exist.', file=sys.stderr)
+        return 2
+    results = [inventory(root, language) for language in ('python', 'typescript')]
+    print(json.dumps({'kind': 'annotation-inventory', 'limitation': 'Not type coverage. Annotations do not establish correctness; TypeScript counts are lexical. Run the configured type checker.', 'results': results}, indent=2))
+    if any(result['errors'] for result in results):
+        return 1
+    return 0 if any(result['files'] for result in results) else 2
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/bundled-skills/mobile-developer/resources/implementation-playbook.md

@@ -0,0 +1,23 @@
+# Mobile feature delivery
+
+## Inputs
+
+Existing stack/version, target OS range, device access, offline requirements and API contract.
+
+## Procedure
+
+1. Use the existing framework and define platform-specific exceptions. Model loading, failed requests, permission denial and offline edits explicitly.
+2. Implement the shared behavior behind tested adapters. Bound retries and define duplicate/conflict handling before queueing writes for reconnection.
+3. Run the feature on each available target, checking background/foreground transitions, network loss, keyboard, accessibility and persistent state after restart.
+
+## Worked example
+
+An offline note is edited twice and synced after reconnecting. Verify one intended final record, a visible conflict policy and no duplicated submission.
+
+## Verification and handoff
+
+Report the actual files or configuration changed, checks performed, observed results and any untested environment. Keep the original inputs and evidence sufficient to reproduce the conclusion.
+
+## Limitations
+
+A cross-platform build does not prove feature parity on untested devices. Store submission and signing remain separate authorized actions.

package/bundled-skills/multi-platform-apps-multi-platform/resources/implementation-playbook.md

@@ -0,0 +1,23 @@
+# Cross-platform parity playbook
+
+## Inputs
+
+Requested platforms, shared API contract, existing stacks, feature acceptance criteria and available tools.
+
+## Procedure
+
+1. Define behavior as observable scenarios, not a percentage of shared code. Record intentional platform differences before implementation.
+2. Implement shared contracts first, then platform adapters. Use available tools directly; agent role names in the main guide describe responsibilities and do not guarantee a delegation API exists.
+3. Maintain a matrix of scenario, platform, observed result and evidence. Check offline conflict handling, permission denial and accessible navigation separately for each target.
+
+## Worked example
+
+A saved item must appear on web and mobile after synchronization. Test add, delete, retry and a conflicting edit on both platforms; identify any platform not exercised.
+
+## Verification and handoff
+
+Report the actual files or configuration changed, checks performed, observed results and any untested environment. Keep the original inputs and evidence sufficient to reproduce the conclusion.
+
+## Limitations
+
+Do not install every framework or manufacture parallel agents. Packaging, store upload and production deployment require the relevant authorization.