@sienklogic/plan-build-run 2.11.0 → 2.12.1

package/plugins/pbr/templates/VERIFICATION-DETAIL.md.tmpl

@@ -3,33 +3,40 @@
 ```yaml
 ---
 phase: "{phase_id}"
-verified: "{ISO timestamp}"
 status: "passed"           # passed | gaps_found | human_needed
+checked_at: "{ISO timestamp}"
 is_re_verification: false  # true if re-verifying after gap closure
-score:
-  total_must_haves: {n}
-  verified: {n}
-  failed: {n}
-  partial: {n}
-  human_needed: {n}
+must_haves_checked: {n}
+must_haves_passed: {n}
+must_haves_failed: {n}
 gaps:
   - must_have: "{description of the failed must-have}"
     level: "{existence | substantive | wired}"
     evidence: "{what you found}"
     recommendation: "{specific action to fix}"
+fix_plans:
+  - gap: "{gap description}"
+    effort: "small"       # small | medium | large
+    tasks:
+      - "{specific fix action with file path}"
 anti_patterns:
   todos: {count}
   stubs: {count}
   console_logs: {count}
   skipped_tests: {count}
   hardcoded_secrets: {count}
+# populated by verifier from implements:[] in plan frontmatter
+satisfied:
+  - "REQ-F-001"    # REQ-IDs confirmed verified in this phase
+unsatisfied:
+  - "REQ-F-002"    # REQ-IDs that failed verification
 ---
 
 # Phase Verification: {phase_name}
 
-> Verified: {date}
+> Checked at: {date}
 > Status: **{STATUS}**
-> Score: {verified}/{total} must-haves verified
+> Score: {must_haves_passed}/{must_haves_checked} must-haves verified
 > Re-verification: {yes/no}
 
 ## Observable Truths
@@ -53,23 +60,52 @@ anti_patterns:
 
 | # | Link Description | Source | Target | Status | Evidence |
 |---|-----------------|--------|--------|--------|----------|
-| 1 | {what connects to what} | `{source_file}` | `{target_file}` | WIRED | Import at L12, called at L45 |
+| 1 | {what connects to what} | `{source_file}` | `{target_file}` | WIRED | Import at L12, called at L45, args correct |
 | 2 | {what connects to what} | `{source_file}` | `{target_file}` | BROKEN | Imported but never called |
+| 3 | {what connects to what} | `{source_file}` | `{target_file}` | ARGS_WRONG | Called at L45 but passes undefined for sessionId (data.session_id in scope) |
 
 ## Gaps Found
 
 {Only present if status is gaps_found}
 
-### Gap 1: {Short description}
+### Critical Gaps
+
+{Gaps that block requirements or core functionality}
+
+#### Gap 1: {Short description}
 
 - **Must-Have**: {which must-have this gap blocks}
+- **Severity**: Critical
 - **Level Failed**: {existence / substantive / wired}
 - **Evidence**: {specific evidence — file paths, line numbers, command output}
 - **Impact**: {what doesn't work because of this gap}
 - **Recommendation**: {specific action to close this gap}
 
-### Gap 2: {Short description}
-...
+### Non-Critical Gaps
+
+{Gaps related to quality, polish, or non-blocking improvements}
+
+#### Gap N: {Short description}
+
+- **Must-Have**: {which must-have this relates to}
+- **Severity**: Non-Critical
+- **Level Failed**: {existence / substantive / wired}
+- **Evidence**: {evidence}
+- **Impact**: {impact}
+- **Recommendation**: {action}
+
+## Recommended Fix Plans
+
+{Auto-generated from gaps. Each gap that can be fixed gets a fix plan.}
+
+### Fix Plan 1: {Gap title}
+**Gap**: {reference to gap}
+**Estimated effort**: {small/medium/large}
+**Tasks**:
+1. {specific fix action with file path}
+2. {verification step}
+
+### Fix Plan 2: ...
 
 ## Human Verification Items
 

package/plugins/pbr/templates/project-CONTEXT.md.tmpl

@@ -0,0 +1,59 @@
+# Project Context
+
+> Cross-cutting decisions that ALL phases must honor.
+> Updated via `/pbr:discuss-phase --project`. Auto-synced to CLAUDE.md on write.
+> Phase-level CONTEXT.md (in phase directories) overrides project-level for that phase.
+>
+> PLANNER NOTE: Embed each locked decision directly into the relevant task's action block.
+> Executors NEVER read this file — PLAN.md is self-contained.
+
+## Locked Decisions
+
+Technology choices, architecture decisions, and constraints that are NON-NEGOTIABLE across ALL phases.
+The planner embeds these into PLAN.md task actions. Executors never read this file directly.
+
+| Decision | Rationale | Locked By |
+|----------|-----------|-----------|
+| {e.g., "Use TypeScript strict mode"} | {User preference, team skill} | User |
+| {e.g., "PostgreSQL via Supabase"} | {Existing infrastructure} | User |
+
+## User Constraints
+
+Budget, timeline, skill level, hosting, team size — factors that shape ALL planning decisions.
+
+- {e.g., "Solo developer, no team"}
+- {e.g., "Deploy to Hetzner VPS"}
+- {e.g., "Must work offline"}
+
+## Specific References
+
+User references, preferences, and "I want it like X" moments that apply across ALL phases.
+These are directional hints for planners, not locked decisions.
+
+- **{Reference}** — {Context from user, e.g., "I want the dashboard to feel like Linear"}
+- **{Reference}** — {Context, e.g., "The auth flow should work like Discord's OAuth"}
+
+## Code Patterns & Reusable Assets
+
+Established patterns, shared utilities, and integration points that planners should leverage
+rather than creating from scratch. Updated as phases complete and patterns emerge.
+
+- **{Pattern/Asset}** — {Location and how to reuse, e.g., "pbr-tools.cjs CLI pattern — use for new CLI commands"}
+- **{Pattern/Asset}** — {Location, e.g., "hooks/hook-logger.js — standard logging for all hook scripts"}
+
+## Deferred Ideas
+
+Ideas explicitly moved to v2 or ruled out. Plans at ANY phase MUST NOT include these.
+
+| Idea | Reason Deferred |
+|------|----------------|
+| {feature} | {reason — e.g., "Post-launch priority"} |
+
+## Claude's Discretion Areas
+
+Areas where planners can make implementation choices without asking the user.
+Document the choice made and rationale when exercised.
+
+| Area | Choice Made | Rationale |
+|------|------------|-----------|
+| {e.g., "Logging library"} | {e.g., "pino"} | {e.g., "Lightweight, structured output"} |

package/plugins/pbr/templates/research-outputs/ARCHITECTURE.md.tmpl

@@ -0,0 +1,91 @@
+<!-- Downstream consumers:
+  - Synthesizer agent: merges architecture findings into SUMMARY.md. Needs: component list, pattern names, data flow summary.
+  - Planner agent: uses architecture for phase dependency ordering. Needs: component dependencies, build order implications, API contract shapes.
+  - Build skill: uses architecture patterns during implementation. Needs: specific patterns tied to the chosen stack, anti-patterns to avoid.
+  Breaks if missing: Planner creates phases with wrong dependency order; build agents implement without architectural guidance.
+-->
+# Architecture Research
+
+**Researched:** {date}
+**Domain:** {domain}
+**Confidence:** {confidence}
+
+## System Architecture
+
+{High-level overview of the system architecture and its major components.}
+
+## Component Diagram
+
+```
+{text_based_component_diagram}
+```
+
+### Component Responsibilities
+
+| Component | Responsibility | Depends On |
+|-----------|----------------|------------|
+| {component} | {responsibility} | {dependencies} |
+
+## Data Flow
+
+### Primary Data Flow
+
+```
+{text_based_data_flow_diagram}
+```
+
+### Key Data Paths
+
+1. **{path_name}:** {description_of_data_flow}
+
+## API Contracts
+
+### {API Endpoint or Interface}
+
+**Request:**
+```
+{request_shape}
+```
+
+**Response:**
+```
+{response_shape}
+```
+
+**Error cases:** {error_description}
+
+## Architecture Patterns
+
+| Pattern | Where Used | Why |
+|---------|-----------|-----|
+| {pattern_name} | {component_or_layer} | {rationale} |
+
+### Pattern Details
+
+#### {Pattern Name}
+
+**What:** {description}
+**When to use:** {conditions}
+**Trade-offs:** {pros_and_cons}
+
+## Anti-Patterns to Avoid
+
+1. **{anti_pattern_name}**
+   - **What people do:** {mistake}
+   - **Why it fails:** {problem}
+   - **Do instead:** {correct_approach}
+
+## Quality Gates
+
+- [ ] Architecture patterns are specific to the chosen stack (not generic advice)
+- [ ] Data flow covers all major paths (happy path, error path, async flows)
+- [ ] API contracts include request shape, response shape, and error cases
+- [ ] Component diagram shows all major components and their connections
+- [ ] At least 2 anti-patterns documented with concrete alternatives
+- [ ] Sources include at least one official documentation or architecture guide reference
+
+## Sources
+
+| # | Type | URL/Description | Confidence |
+|---|------|----------------|------------|
+| S1 | {type} | {url_or_description} | {HIGH/MEDIUM/LOW} |

package/plugins/pbr/templates/research-outputs/FEATURES.md.tmpl

@@ -0,0 +1,64 @@
+<!-- Downstream consumers:
+  - Synthesizer agent: merges feature findings into SUMMARY.md. Needs: categorized feature list with priorities and effort estimates.
+  - Planner agent: uses feature priorities for requirement prioritization and phase scoping. Needs: must-have/should-have/defer categorization, effort estimates.
+  - Begin skill: presents feature inventory to user for scope discussion. Needs: clear feature descriptions with competitive context.
+  Breaks if missing: Planner scopes phases without feature priority data; synthesizer produces SUMMARY with no feature guidance.
+-->
+# Features Research
+
+**Researched:** {date}
+**Domain:** {domain}
+**Confidence:** {confidence}
+
+## Feature Inventory
+
+| Feature | Category | Priority | Effort | Description |
+|---------|----------|----------|--------|-------------|
+| {feature} | {category} | {must-have/should-have/defer} | {S/M/L/XL} | {brief_description} |
+
+## Competitive Analysis
+
+| Feature | Our Approach | Alternative 1 | Alternative 2 | Tradeoff |
+|---------|-------------|---------------|---------------|----------|
+| {feature} | {our_approach} | {alt_1} | {alt_2} | {tradeoff_analysis} |
+
+## Prioritization Rationale
+
+### Must-Have (table stakes)
+
+{Features users expect as baseline. Without these, the product is not viable.}
+
+- **{feature}:** {why_must_have}
+
+### Should-Have (competitive)
+
+{Features that differentiate from alternatives. Important but not blocking launch.}
+
+- **{feature}:** {why_should_have}
+
+### Defer (v2+)
+
+{Features explicitly excluded from initial scope with rationale.}
+
+- **{feature}:** {why_defer}
+
+## Deferred Features
+
+| Feature | Reason Deferred | Revisit When | Effort if Added Later |
+|---------|----------------|--------------|----------------------|
+| {feature} | {reason} | {trigger} | {effort_estimate} |
+
+## Quality Gates
+
+- [ ] Every feature categorized as must-have, should-have, or defer
+- [ ] Effort estimates present for all features (S/M/L/XL)
+- [ ] Competitive analysis has at least 2 alternatives per major feature
+- [ ] Must-have features have clear rationale for why they are table stakes
+- [ ] Deferred features include revisit triggers
+- [ ] Sources include at least one market or user research reference
+
+## Sources
+
+| # | Type | URL/Description | Confidence |
+|---|------|----------------|------------|
+| S1 | {type} | {url_or_description} | {HIGH/MEDIUM/LOW} |

package/plugins/pbr/templates/research-outputs/PITFALLS.md.tmpl

@@ -0,0 +1,50 @@
+<!-- Downstream consumers:
+  - Synthesizer agent: merges pitfall findings into SUMMARY.md. Needs: numbered pitfalls with severity and avoidance strategies.
+  - Planner agent: reads pitfalls to add defensive verification steps to plans. Needs: specific, actionable avoidance strategies.
+  - Build skill: uses avoidance strategies during implementation. Needs: detection methods to catch pitfalls early.
+  Breaks if missing: Plans lack defensive verification; synthesizer produces SUMMARY with no risk awareness.
+-->
+# Pitfalls Research
+
+**Researched:** {date}
+**Domain:** {domain}
+**Confidence:** {confidence}
+
+## Critical Pitfalls
+
+{Pitfalls that cause project failure or major rework if not avoided.}
+
+1. **{pitfall_name}** [{source}]
+   - **Impact:** {what_goes_wrong}
+   - **Root cause:** {why_it_happens}
+   - **Avoidance:** {specific_steps_to_prevent}
+   - **Detection:** {how_to_catch_early}
+
+## Common Mistakes
+
+{Mistakes that cause delays but are recoverable.}
+
+1. **{mistake_name}** [{source}]
+   - **Impact:** {what_goes_wrong}
+   - **Avoidance:** {what_to_do_instead}
+
+## Environment-Specific Gotchas
+
+| Environment | Gotcha | Workaround |
+|-------------|--------|------------|
+| {env} | {issue} | {fix} |
+
+## Quality Gates
+
+- [ ] At least 3 critical pitfalls identified with source attribution
+- [ ] Each critical pitfall has a concrete avoidance strategy (not "be careful")
+- [ ] Each critical pitfall has a detection method
+- [ ] Environment-specific gotchas checked for target platform
+- [ ] Common mistakes section has at least 2 entries
+- [ ] Sources include at least one official documentation reference
+
+## Sources
+
+| # | Type | URL/Description | Confidence |
+|---|------|----------------|------------|
+| S1 | {type} | {url_or_description} | {HIGH/MEDIUM/LOW} |

package/plugins/pbr/templates/research-outputs/STACK.md.tmpl

@@ -0,0 +1,63 @@
+<!-- Downstream consumers:
+  - Synthesizer agent: merges stack findings into SUMMARY.md. Needs: technology table with versions and rationale, confidence levels per recommendation.
+  - Planner agent: uses stack decisions for phase planning and dependency ordering. Needs: prescriptive technology choices (not "consider X or Y"), version numbers, package manager.
+  - Dashboard ResearchTab: displays research confidence. Needs: frontmatter confidence field.
+  Breaks if missing: Synthesizer produces SUMMARY with vague stack section; planner makes technology decisions without research backing.
+-->
+# Stack Research
+
+**Researched:** {date}
+**Domain:** {domain}
+**Confidence:** {confidence}
+
+## Core Stack
+
+| Technology | Version | Purpose | Why Standard |
+|------------|---------|---------|--------------|
+| {technology} | {version} | {purpose} | {rationale} |
+
+## Supporting Tools
+
+| Tool | Version | Purpose | When to Use |
+|------|---------|---------|-------------|
+| {tool} | {version} | {purpose} | {use_case} |
+
+## Package Manager
+
+**Recommended:** {package_manager}
+**Why:** {rationale}
+
+## Deployment Target
+
+| Property | Value | Notes |
+|----------|-------|-------|
+| Platform | {platform} | {notes} |
+| Hosting | {hosting} | {notes} |
+| CI/CD | {ci_cd} | {notes} |
+
+## Alternatives Considered
+
+| Recommended | Alternative | Why Not |
+|-------------|-------------|---------|
+| {our_choice} | {alternative} | {rejection_reason} |
+
+## Version Compatibility
+
+| Package A | Compatible With | Notes |
+|-----------|-----------------|-------|
+| {package_a} | {package_b} | {compatibility_notes} |
+
+## Quality Gates
+
+- [ ] All technology recommendations are prescriptive ("Use X") not exploratory ("Consider X or Y")
+- [ ] Every technology entry has a specific version number (not "latest")
+- [ ] Core stack table has at least 3 entries
+- [ ] Alternatives Considered table documents at least 2 rejected alternatives with rationale
+- [ ] Package manager recommendation includes rationale
+- [ ] Sources include at least one official documentation reference
+
+## Sources
+
+| # | Type | URL/Description | Confidence |
+|---|------|----------------|------------|
+| S1 | {type} | {url_or_description} | {HIGH/MEDIUM/LOW} |

package/plugins/pbr/templates/research-outputs/SUMMARY.md.tmpl

@@ -0,0 +1,98 @@
+<!-- Downstream consumers:
+  - Planner agent (primary consumer): reads SUMMARY.md for all phase planning decisions. Needs: stack recommendation, architecture recommendation, key risks, feature priorities, confidence assessment.
+  - Begin skill: presents synthesis to user for approval before roadmap creation. Needs: executive summary, consolidated recommendations.
+  - Dashboard ResearchTab: displays synthesis with confidence levels. Needs: confidence assessment table, research coverage.
+  Breaks if missing: Planner makes phase decisions without research backing; user approves roadmap without seeing synthesis; dashboard shows empty research card.
+-->
+# Research Synthesis
+
+**Synthesized:** {date}
+**Input documents:** {count}
+**Confidence:** {overall_confidence}
+
+## Executive Summary
+
+{Unified findings across all research dimensions in under 200 words. State: what was researched, key conclusions, primary recommendation, and confidence level.}
+
+## Stack Recommendation
+
+**Recommended stack:** {one_line_summary}
+
+{Key technology choices with rationale, sourced from STACK research.}
+
+- **{technology}:** {version} -- {why_chosen}
+
+## Architecture Recommendation
+
+**Recommended pattern:** {pattern_name}
+
+{Architecture approach with component overview, sourced from ARCHITECTURE research.}
+
+- **{component}:** {responsibility}
+
+## Key Risks
+
+{Top risks from PITFALLS research, ordered by impact.}
+
+1. **{risk}** -- {mitigation}
+2. **{risk}** -- {mitigation}
+3. **{risk}** -- {mitigation}
+
+## Feature Priorities
+
+{Prioritized feature summary from FEATURES research.}
+
+**Must-have:** {must_have_features}
+**Should-have:** {should_have_features}
+**Deferred:** {deferred_features}
+
+## Consolidated Recommendations
+
+{Actionable recommendations that integrate findings across all dimensions.}
+
+1. {recommendation}
+2. {recommendation}
+3. {recommendation}
+
+## Confidence Assessment
+
+| Dimension | Confidence | Gaps |
+|-----------|------------|------|
+| Stack | {HIGH/MEDIUM/LOW} | {gaps_or_none} |
+| Features | {HIGH/MEDIUM/LOW} | {gaps_or_none} |
+| Architecture | {HIGH/MEDIUM/LOW} | {gaps_or_none} |
+| Pitfalls | {HIGH/MEDIUM/LOW} | {gaps_or_none} |
+
+**Overall confidence:** {confidence}
+
+## Research Coverage
+
+| Dimension | Status | Notes |
+|-----------|--------|-------|
+| Stack | {COMPLETE/PARTIAL/MISSING} | {notes} |
+| Features | {COMPLETE/PARTIAL/MISSING} | {notes} |
+| Architecture | {COMPLETE/PARTIAL/MISSING} | {notes} |
+| Pitfalls | {COMPLETE/PARTIAL/MISSING} | {notes} |
+
+**Dimensions researched:** {count}/4
+**Gaps requiring attention:** {list_or_none}
+
+## Quality Gates
+
+- [ ] Executive summary is under 200 words
+- [ ] All 4 research dimensions referenced (Stack, Features, Architecture, Pitfalls)
+- [ ] Confidence gaps explicitly listed for each dimension
+- [ ] Recommendations are prescriptive and actionable (not "consider" or "evaluate")
+- [ ] Partial failure handled -- missing dimensions noted, not silently omitted
+- [ ] Sources consolidated from all input documents
+
+## Sources
+
+### Primary (HIGH confidence)
+- {source}
+
+### Secondary (MEDIUM confidence)
+- {source}
+
+### Tertiary (LOW confidence)
+- {source}

package/scripts/build-hooks.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * Copy PBR hooks to dist for installation.
+ *
+ * Dynamically discovers all .js files in hooks/ and copies them along
+ * with hooks.json and hooks-schema.json to hooks/dist/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HOOKS_DIR = path.join(__dirname, '..', 'hooks');
+const DIST_DIR = path.join(HOOKS_DIR, 'dist');
+
+// Static assets to copy alongside hook scripts
+const STATIC_FILES = [
+  'hooks.json',
+  'hooks-schema.json'
+];
+
+function build() {
+  // Ensure dist directory exists
+  if (!fs.existsSync(DIST_DIR)) {
+    fs.mkdirSync(DIST_DIR, { recursive: true });
+  }
+
+  // Discover all .js files in hooks/
+  const jsFiles = fs.readdirSync(HOOKS_DIR).filter(f => f.endsWith('.js'));
+
+  // Copy all .js hook scripts
+  let copied = 0;
+  for (const file of jsFiles) {
+    const src = path.join(HOOKS_DIR, file);
+    const dest = path.join(DIST_DIR, file);
+
+    console.log(`Copying ${file}...`);
+    fs.copyFileSync(src, dest);
+    console.log(`  → ${dest}`);
+    copied++;
+  }
+
+  // Copy static assets (hooks.json, hooks-schema.json)
+  for (const file of STATIC_FILES) {
+    const src = path.join(HOOKS_DIR, file);
+    const dest = path.join(DIST_DIR, file);
+
+    if (!fs.existsSync(src)) {
+      console.warn(`Warning: ${file} not found, skipping`);
+      continue;
+    }
+
+    console.log(`Copying ${file}...`);
+    fs.copyFileSync(src, dest);
+    console.log(`  → ${dest}`);
+    copied++;
+  }
+
+  console.log(`\nBuild complete. ${copied} files copied.`);
+}
+
+build();

package/scripts/check-ci.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * check-ci.js — Check GitHub Actions CI status and cache for the status line.
+ *
+ * Writes .planning/.ci-status.json with the latest CI run status.
+ * The status line reads this file to show CI pass/fail/pending.
+ *
+ * Usage:
+ *   node scripts/check-ci.js          # Check latest run for current branch
+ *   node scripts/check-ci.js --watch  # Check and exit non-zero on failure
+ *
+ * Requires: gh CLI authenticated with repo access.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const planningDir = path.join(process.cwd(), '.planning');
+const ciFile = path.join(planningDir, '.ci-status.json');
+
+function main() {
+  const watch = process.argv.includes('--watch');
+
+  // Get current branch
+  let branch;
+  try {
+    branch = cp.execSync('git branch --show-current', {
+      encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+  } catch (_e) {
+    console.error('check-ci: not in a git repo');
+    process.exit(1);
+  }
+
+  // Get latest CI run via gh CLI
+  let runs;
+  try {
+    const output = cp.execSync(
+      `gh run list --branch ${branch} --limit 1 --json status,conclusion,headBranch,event,createdAt,name,databaseId`,
+      { encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    runs = JSON.parse(output);
+  } catch (e) {
+    // gh CLI not available or not authenticated
+    console.error('check-ci: gh CLI failed —', e.message || 'unknown error');
+    // Write unknown status so status line knows we tried
+    writeStatus({ status: 'unknown', branch, error: 'gh CLI unavailable' });
+    return;
+  }
+
+  if (!runs || runs.length === 0) {
+    console.log(`check-ci: no CI runs found for branch '${branch}'`);
+    writeStatus({ status: 'none', branch });
+    return;
+  }
+
+  const run = runs[0];
+  let status;
+
+  if (run.status === 'completed') {
+    status = run.conclusion === 'success' ? 'pass' : 'fail';
+  } else if (run.status === 'in_progress' || run.status === 'queued') {
+    status = 'pending';
+  } else {
+    status = 'unknown';
+  }
+
+  const result = {
+    status,
+    branch,
+    conclusion: run.conclusion || null,
+    name: run.name || null,
+    runId: run.databaseId || null,
+    createdAt: run.createdAt || null,
+    timestamp: new Date().toISOString()
+  };
+
+  writeStatus(result);
+
+  const icons = { pass: '✓', fail: '✗', pending: '○', unknown: '?', none: '-' };
+  const icon = icons[status] || '?';
+  console.log(`check-ci: ${icon} ${status} — ${run.name || 'CI'} on ${branch}`);
+
+  if (watch && status === 'fail') {
+    process.exit(1);
+  }
+}
+
+function writeStatus(data) {
+  if (!fs.existsSync(planningDir)) {
+    fs.mkdirSync(planningDir, { recursive: true });
+  }
+  fs.writeFileSync(ciFile, JSON.stringify(data, null, 2), 'utf8');
+}
+
+main();