@codyswann/lisa 1.0.0 → 1.0.5

package/all/copy-overwrite/.claude/commands/tasks/load.md

@@ -0,0 +1,63 @@
+---
+description: Load tasks from a project directory into the current session
+argument-hint: <project-name>
+allowed-tools: Read, Bash, TaskCreate, TaskUpdate, TaskList
+---
+
+# Load Project Tasks
+
+Load tasks from `projects/$ARGUMENTS/tasks/` into the current Claude Code session.
+
+## Process
+
+### Step 1: Validate Project
+
+Check if the project exists:
+
+```bash
+ls projects/$ARGUMENTS/tasks/*.json 2>/dev/null
+```
+
+If no task files exist, report: "No tasks found in projects/$ARGUMENTS/tasks/"
+
+### Step 2: Set Active Project
+
+Create the active project marker:
+
+```bash
+echo "$ARGUMENTS" > .claude-active-project
+```
+
+This ensures any new tasks created will sync back to this project.
+
+### Step 3: Load Tasks
+
+For each JSON file in `projects/$ARGUMENTS/tasks/`:
+
+1. Read the task JSON file
+2. Use TaskCreate to recreate the task with:
+   - subject from JSON
+   - description from JSON
+   - activeForm from JSON
+   - metadata: `{ "project": "$ARGUMENTS" }`
+3. If the task was already completed (status: "completed"), use TaskUpdate to mark it completed
+
+### Step 4: Report
+
+After loading all tasks, report:
+
+```
+Loaded X tasks from projects/$ARGUMENTS/tasks/
+- Pending: Y
+- Completed: Z
+
+Active project set to: $ARGUMENTS
+New tasks will automatically sync to this project.
+```
+
+## Notes
+
+- Tasks are recreated with new IDs in the current session
+- The original task IDs from the project are not preserved
+- Task dependencies (blocks/blockedBy) are NOT currently preserved across load/sync cycles
+- Use TaskList to see the loaded tasks

package/all/copy-overwrite/.claude/commands/tasks/sync.md

@@ -0,0 +1,84 @@
+---
+description: Sync current session tasks to a project directory
+argument-hint: <project-name>
+allowed-tools: Read, Write, Bash, TaskList, TaskGet
+---
+
+# Sync Tasks to Project
+
+Sync all tasks from the current session to `projects/$ARGUMENTS/tasks/`.
+
+## Process
+
+### Step 1: Validate Project
+
+Check if the project directory exists:
+
+```bash
+ls -d projects/$ARGUMENTS 2>/dev/null
+```
+
+If the project doesn't exist, ask: "Project '$ARGUMENTS' doesn't exist. Create it?"
+
+If yes, create the project structure:
+
+```bash
+mkdir -p projects/$ARGUMENTS/tasks
+```
+
+### Step 2: Set Active Project
+
+Create/update the active project marker:
+
+```bash
+echo "$ARGUMENTS" > .claude-active-project
+```
+
+### Step 3: Get Current Tasks
+
+Use TaskList to get all tasks in the current session.
+
+### Step 4: Sync Each Task
+
+For each task from TaskList:
+
+1. Use TaskGet to get full task details
+2. Create a JSON file with the task data:
+
+```json
+{
+  "id": "<task-id>",
+  "subject": "<subject>",
+  "description": "<description>",
+  "activeForm": "<activeForm>",
+  "status": "<status>",
+  "blocks": [],
+  "blockedBy": []
+}
+```
+
+3. Write to `projects/$ARGUMENTS/tasks/<id>.json`
+
+### Step 5: Stage for Git
+
+```bash
+git add projects/$ARGUMENTS/tasks/*.json
+```
+
+### Step 6: Report
+
+```
+Synced X tasks to projects/$ARGUMENTS/tasks/
+- Pending: Y
+- In Progress: Z
+- Completed: W
+
+Files staged for commit. Run /git:commit when ready.
+```
+
+## Notes
+
+- This command manually syncs all current tasks to a project
+- Use this when you started work without a project context
+- After syncing, the active project is set so future tasks auto-sync
+- Existing task files in the project directory will be overwritten

package/all/copy-overwrite/.claude/hooks/README.md

@@ -154,6 +154,81 @@ Note: The hooks run in order. ESLint runs first to fix linting issues, then Pret
 - [Claude Code Hooks Guide](https://docs.claude.com/en/docs/claude-code/hooks-guide)
 - [Hooks Reference](https://docs.claude.com/en/docs/claude-code/hooks)
 
+### check-tired-boss.sh
+
+**Type**: Stop hook (blocking)
+**Trigger**: When Claude finishes responding
+**Purpose**: Verifies Claude's response starts with "I'm tired boss" as required by CLAUDE.md
+
+#### How it works
+
+1. The hook is triggered when Claude finishes responding (Stop event)
+2. Reads the transcript file to get Claude's last assistant message
+3. Checks if the response starts with "I'm tired boss"
+4. If compliant, allows the response to complete normally
+5. If non-compliant, blocks the Stop event with an error message telling Claude to read CLAUDE.md and try again
+
+#### Why this hook exists
+
+CLAUDE.md requires: "Always output 'I'm tired boss' before starting any task, request or anything else."
+
+This hook enforces that rule by checking every response and forcing Claude to retry if it doesn't comply.
+
+#### Configuration
+
+The hook is configured in `.claude/settings.json` and runs before the notification hook:
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo 'REMINDER: Start your response with \"I'\\''m tired boss\" as required by CLAUDE.md.'",
+            "timeout": 1
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/check-tired-boss.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/notify-ntfy.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+#### Features
+
+- **Blocking enforcement**: Non-compliant responses are blocked with clear feedback
+- **Reminder injection**: UserPromptSubmit hook reminds Claude before it responds
+- **Cross-platform**: Uses POSIX-compatible shell commands (works on macOS and Linux)
+- **Graceful fallback**: Uses jq for JSON parsing when available, falls back to grep/sed
+- **Order-aware**: Runs before notification hook so failed attempts don't trigger "finished" notifications
+
+#### Limitations
+
+- The user will see the non-compliant response before Claude is forced to retry
+- Works through after-the-fact enforcement rather than prevention (no PreResponse hook exists)
+
+---
+
 ### notify-ntfy.sh
 
 **Type**: Notification and Stop hooks

package/all/copy-overwrite/.claude/hooks/check-tired-boss.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# This file is managed by Lisa.
+# Do not edit directly — changes will be overwritten on the next `lisa` run.
+# =============================================================================
+# CLAUDE.md Compliance Hook - "I'm tired boss" Verification
+# =============================================================================
+# Verifies Claude's response starts with "I'm tired boss" as required by
+# CLAUDE.md. This is a Stop hook that blocks if Claude doesn't comply,
+# forcing a retry with an error message.
+#
+# @see CLAUDE.md - "Always output 'I'm tired boss' before starting any task"
+# =============================================================================
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract transcript path
+TRANSCRIPT_PATH=$(echo "$INPUT" | grep -o '"transcript_path"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*: *"//' | sed 's/"$//')
+
+# Exit silently if no transcript available
+if [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
+    exit 0
+fi
+
+# Extract the last assistant message from the transcript
+# Use awk for cross-platform compatibility (tac not available on macOS)
+LAST_ASSISTANT=$(awk '/"type"[[:space:]]*:[[:space:]]*"assistant"/{line=$0} END{if(line) print line}' "$TRANSCRIPT_PATH" 2>/dev/null)
+
+if [ -z "$LAST_ASSISTANT" ]; then
+    exit 0
+fi
+
+# Extract the text content from the assistant message
+# Use jq for robust JSON parsing when available, fallback to grep/sed
+RESPONSE_TEXT=""
+if command -v jq >/dev/null 2>&1; then
+    RESPONSE_TEXT=$(echo "$LAST_ASSISTANT" | jq -r '.message.content[] | select(.type == "text") | .text' 2>/dev/null | head -1)
+else
+    # Fallback: simple regex extraction (may fail on escaped quotes)
+    RESPONSE_TEXT=$(echo "$LAST_ASSISTANT" | grep -o '"text"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*: *"//' | sed 's/"$//')
+fi
+
+# Exit if no text content found
+if [ -z "$RESPONSE_TEXT" ]; then
+    exit 0
+fi
+
+# Check if response starts with "I'm tired boss" (case-sensitive)
+REQUIRED_PHRASE="I'm tired boss"
+if echo "$RESPONSE_TEXT" | head -1 | grep -q "^$REQUIRED_PHRASE"; then
+    # Compliance verified
+    exit 0
+fi
+
+# Non-compliant - block and provide feedback
+# Output JSON to block the Stop event
+cat << 'EOF'
+{"decision":"block","reason":"Your response did not start with \"I'm tired boss\". Read @CLAUDE.md and try again. Every response MUST begin with this exact phrase."}
+EOF
+
+exit 0

package/all/copy-overwrite/.claude/hooks/debug-hook.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+##
+# Debug hook that logs all hook events when CLAUDE_DEBUG=1
+# This script is a no-op when CLAUDE_DEBUG is not set or set to 0
+##
+
+# Exit immediately if debug mode is not enabled
+if [[ "${CLAUDE_DEBUG:-0}" != "1" ]]; then
+  exit 0
+fi
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse hook event info using jq
+HOOK_EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"')
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // "N/A"')
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+CWD=$(echo "$INPUT" | jq -r '.cwd // "unknown"')
+PERMISSION_MODE=$(echo "$INPUT" | jq -r '.permission_mode // "unknown"')
+
+# Create debug log directory if it doesn't exist
+DEBUG_LOG_DIR="${CLAUDE_PROJECT_DIR:-.}/.claude/debug"
+mkdir -p "$DEBUG_LOG_DIR"
+
+# Log file with session ID
+LOG_FILE="$DEBUG_LOG_DIR/hooks-${SESSION_ID}.log"
+
+# Timestamp
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+
+# Log the event
+{
+  echo "[$TIMESTAMP] Hook: $HOOK_EVENT"
+  echo "  Tool: $TOOL_NAME"
+  echo "  Session: $SESSION_ID"
+  echo "  CWD: $CWD"
+  echo "  Permission Mode: $PERMISSION_MODE"
+  echo "  Full Input:"
+  echo "$INPUT" | jq '.' | sed 's/^/    /'
+  echo "---"
+} >> "$LOG_FILE"
+
+# Also output to stderr in verbose mode (won't affect Claude)
+echo "[DEBUG] Hook fired: $HOOK_EVENT (tool: $TOOL_NAME)" >&2
+
+exit 0

package/all/copy-overwrite/.claude/hooks/notify-ntfy.sh

@@ -1,4 +1,6 @@
 #!/bin/bash
+# This file is managed by Lisa.
+# Do not edit directly — changes will be overwritten on the next `lisa` run.
 # =============================================================================
 # ntfy.sh Notification Hook for Claude Code
 # =============================================================================

package/all/copy-overwrite/.claude/hooks/sync-tasks.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+#
+# sync-tasks.sh - Syncs Claude Code tasks to project directories
+#
+# This hook is triggered on PostToolUse for TaskCreate and TaskUpdate.
+# It reads the task metadata to determine the project and syncs
+# task JSON files to ./projects/{project}/tasks/
+#
+# Input (via stdin): JSON with tool_name, tool_input, tool_output
+#
+
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract tool name
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty')
+
+# Only process TaskCreate and TaskUpdate
+if [[ "$TOOL_NAME" != "TaskCreate" && "$TOOL_NAME" != "TaskUpdate" ]]; then
+  exit 0
+fi
+
+# Try to get project from multiple sources:
+# 1. Task metadata (passed in tool_input)
+# 2. .claude-active-project marker file
+
+PROJECT=""
+
+# Check tool_input metadata for project
+PROJECT=$(echo "$INPUT" | jq -r '.tool_input.metadata.project // empty')
+
+# If no project in metadata, check marker file
+if [[ -z "$PROJECT" && -f ".claude-active-project" ]]; then
+  PROJECT=$(cat .claude-active-project | tr -d '[:space:]')
+fi
+
+# If still no project, skip syncing
+if [[ -z "$PROJECT" ]]; then
+  exit 0
+fi
+
+# Validate project name (kebab-case, no path traversal)
+if [[ ! "$PROJECT" =~ ^[a-z0-9-]+$ ]]; then
+  echo "Warning: Invalid project name '$PROJECT', skipping sync" >&2
+  exit 0
+fi
+
+# Get task ID
+TASK_ID=""
+if [[ "$TOOL_NAME" == "TaskCreate" ]]; then
+  # For TaskCreate, ID is in tool_output
+  TASK_ID=$(echo "$INPUT" | jq -r '.tool_output.taskId // .tool_output.id // empty')
+elif [[ "$TOOL_NAME" == "TaskUpdate" ]]; then
+  # For TaskUpdate, ID is in tool_input
+  TASK_ID=$(echo "$INPUT" | jq -r '.tool_input.taskId // empty')
+fi
+
+if [[ -z "$TASK_ID" ]]; then
+  exit 0
+fi
+
+# Find the task file in ~/.claude/tasks/
+# Tasks are stored in ~/.claude/tasks/{session-uuid}/{id}.json
+CLAUDE_TASKS_DIR="${HOME}/.claude/tasks"
+TASK_FILE=""
+
+# Get session ID from hook input (preferred - 100% accurate)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+
+if [[ -n "$SESSION_ID" && -f "${CLAUDE_TASKS_DIR}/${SESSION_ID}/${TASK_ID}.json" ]]; then
+  # Use session ID directly - guaranteed correct session
+  TASK_FILE="${CLAUDE_TASKS_DIR}/${SESSION_ID}/${TASK_ID}.json"
+else
+  # Fallback: find most recently modified task file with this ID
+  # This handles edge cases where session_id isn't available
+  TASK_FILE=$(find "$CLAUDE_TASKS_DIR" -name "${TASK_ID}.json" -exec stat -f '%m %N' {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-)
+fi
+
+if [[ -z "$TASK_FILE" || ! -f "$TASK_FILE" ]]; then
+  exit 0
+fi
+
+# Ensure project tasks directory exists
+PROJECT_TASKS_DIR="./projects/${PROJECT}/tasks"
+mkdir -p "$PROJECT_TASKS_DIR"
+
+# Copy task file to project directory
+cp "$TASK_FILE" "${PROJECT_TASKS_DIR}/${TASK_ID}.json"
+
+# Optionally stage the file for git (non-blocking)
+git add "${PROJECT_TASKS_DIR}/${TASK_ID}.json" 2>/dev/null || true
+
+exit 0

package/all/copy-overwrite/.claude/{skills/coding-philosophy/SKILL.md → rules/coding-philosophy.md}

@@ -1,13 +1,6 @@
----
-name: coding-philosophy
-description: Enforces immutable coding principles, function structure ordering, functional programming patterns, TDD, clean deletion, and YAGNI+SOLID+DRY+KISS principles for this codebase. This skill should be used when writing or reviewing TypeScript/React code in this project, particularly when creating hooks, utility functions, or components. Use this skill to ensure code follows the established patterns for immutability, proper ordering of statements, functional transformations, test-driven development, and simplicity (preferring Occam's Razor/KISS when principles conflict).
----
-
 # Coding Philosophy
 
-## Overview
-
-This skill enforces the core coding philosophy for this project: **immutability**, **predictable structure**, **functional transformations**, **test-driven development**, **clean deletion**, and **simplicity**. All code should follow these principles to maintain consistency, testability, and clarity.
+This rule enforces the core coding philosophy: **immutability**, **predictable structure**, **functional transformations**, **test-driven development**, **clean deletion**, and **simplicity**.
 
 ## Guiding Principles: YAGNI + SOLID + DRY + KISS
 
@@ -15,7 +8,7 @@ Follow these software engineering principles, **deferring to Occam's Razor/KISS
 
 ### KISS (Keep It Simple, Stupid) - The Tiebreaker
 
-When principles conflict, **always choose the simpler solution**. Occam's Razor applies to code: the simplest solution that works is usually correct.
+When principles conflict, **always choose the simpler solution**.
 
 ```typescript
 // KISS: Simple direct approach
@@ -46,18 +39,8 @@ Extract duplication only when:
 2. The abstraction is **simpler** than the duplication
 3. The extracted code has a **clear single purpose**
 
-```typescript
-// DRY + KISS: Extract when clearly beneficial
-const formatPlayerName = (first: string, last: string) => `${first} ${last}`;
-
-// Anti-pattern: Premature abstraction for 2 usages
-// Keep inline if simpler and only used twice
-```
-
 ### SOLID Principles - Applied Pragmatically
 
-Apply SOLID when it **reduces complexity**, not dogmatically:
-
 | Principle                 | Apply When                                    | Skip When                               |
 | ------------------------- | --------------------------------------------- | --------------------------------------- |
 | **S**ingle Responsibility | Function does 2+ unrelated things             | Splitting adds complexity               |
@@ -66,21 +49,15 @@ Apply SOLID when it **reduces complexity**, not dogmatically:
 | **I**nterface Segregation | Consumers need different subsets              | Interface is already small              |
 | **D**ependency Inversion  | Testing requires mocking external services    | Direct dependency is simpler            |
 
-```typescript
-// Good SRP: Each function has one job
-const validateEmail = (email: string) => EMAIL_REGEX.test(email);
-const formatEmail = (email: string) => email.toLowerCase().trim();
-
-// Over-applied SRP: Don't split a simple 3-line function into 3 files
-```
-
 ### Decision Framework
 
 When unsure, ask in order:
-1. **Do I need this now?** (YAGNI) → If no, don't build it
-2. **Is there a simpler way?** (KISS) → Choose the simpler option
-3. **Am I repeating myself 3+ times?** (DRY) → Extract if the abstraction is simpler
-4. **Does this function do one thing?** (SOLID-SRP) → Split only if clearer
+1. **Do I need this now?** (YAGNI) - If no, don't build it
+2. **Is there a simpler way?** (KISS) - Choose the simpler option
+3. **Am I repeating myself 3+ times?** (DRY) - Extract if the abstraction is simpler
+4. **Does this function do one thing?** (SOLID-SRP) - Split only if clearer
+
+---
 
 ## Core Principles
 
@@ -100,7 +77,7 @@ user.name = "New Name";
 
 All functions, hooks, and components follow a strict ordering:
 
-```
+```text
 1. Variable definitions and derived state (const, useState, useMemo, useCallback)
 2. Side effects (useEffect, function calls with no return value)
 3. Return statement
@@ -123,49 +100,24 @@ users.forEach(u => names.push(u.name));
 
 **Always write failing tests before implementation code.** This is mandatory, not optional.
 
-```
+```text
 TDD Cycle:
 1. RED: Write a failing test that defines expected behavior
 2. GREEN: Write the minimum code to make the test pass
 3. REFACTOR: Clean up while keeping tests green
 ```
 
-```typescript
-// Step 1: Write the failing test FIRST
-describe("formatPlayerName", () => {
-  it("should format first and last name", () => {
-    expect(formatPlayerName("John", "Doe")).toBe("John Doe");
-  });
-
-  it("should handle empty last name", () => {
-    expect(formatPlayerName("John", "")).toBe("John");
-  });
-});
-
-// Step 2: THEN write implementation to make tests pass
-const formatPlayerName = (first: string, last: string): string =>
-  last ? `${first} ${last}` : first;
-```
-
-**TDD is non-negotiable because it:**
-- Forces you to think about the API before implementation
-- Ensures every feature has test coverage
-- Prevents over-engineering (you only write what's needed to pass tests)
-- Documents expected behavior
-
 ### 5. Clean Deletion
 
 **Delete old code completely.** No deprecation warnings, migration shims, or backward-compatibility layers unless explicitly requested.
 
 ```typescript
 // Correct: Remove the old code entirely
-// (Old function is gone, new function exists)
 const calculateScore = (player: Player): number => player.stats.overall;
 
 // Wrong: Keeping deprecated versions around
 /** @deprecated Use calculateScore instead */
 const getPlayerScore = (player: Player): number => calculateScore(player);
-const calculateScoreV2 = (player: Player): number => player.stats.overall;
 ```
 
 **Clean deletion rules:**
@@ -175,18 +127,7 @@ const calculateScoreV2 = (player: Player): number => player.stats.overall;
 - Never write migration code unless explicitly asked
 - Trust git history for recovery if needed
 
-**Why clean deletion:**
-- Reduces cognitive load (one way to do things)
-- Prevents confusion about which version to use
-- Keeps bundle size small
-- YAGNI: If no one is using it, delete it
-
-## Detailed Guidelines
-
-For comprehensive examples and patterns, see the reference files:
-
-- **[references/immutable-patterns.md](references/immutable-patterns.md)** - Detailed immutable patterns with reduce, spread, and functional transformations
-- **[references/function-structure.md](references/function-structure.md)** - Function ordering rules and examples for hooks, utilities, and components
+---
 
 ## Quick Reference
 
@@ -244,6 +185,8 @@ if (isComplete) {
 }
 ```
 
+---
+
 ## Hook Structure Example
 
 ```typescript
@@ -334,6 +277,8 @@ export const calculateTeamRankings = (
 };
 ```
 
+---
+
 ## Anti-Patterns to Avoid
 
 ### Never use `let` for conditional assignment
@@ -403,3 +348,81 @@ useEffect(() => {
   /* ... */
 }, [value]);
 ```
+
+---
+
+## Immutable Patterns Reference
+
+### Building Lookup Objects with Reduce
+
+```typescript
+const colorMap =
+  edges?.reduce(
+    (acc, edge) => (edge.color ? { ...acc, [edge.tagId]: edge.color } : acc),
+    {} as Record<string, string>
+  ) ?? {};
+```
+
+### Accumulating Multiple Properties
+
+```typescript
+const teamGprAccumulator = validPlayers.reduce(
+  (acc, player) => {
+    const teamId = player.team?.id;
+    if (!teamId) return acc;
+
+    const existing = acc[teamId];
+    return {
+      ...acc,
+      [teamId]: {
+        teamId,
+        teamName: player.team.name,
+        gprSum: (existing?.gprSum ?? 0) + player.gpr,
+        playerCount: (existing?.playerCount ?? 0) + 1,
+      },
+    };
+  },
+  {} as Record<string, { teamId: string; teamName: string; gprSum: number; playerCount: number }>
+);
+```
+
+### Nested Object Updates
+
+```typescript
+const updated = {
+  ...state,
+  user: {
+    ...state.user,
+    profile: {
+      ...state.user.profile,
+      avatar: newAvatar,
+    },
+  },
+};
+```
+
+### Conditional Property Addition
+
+```typescript
+const result = {
+  ...baseObj,
+  ...(condition && { optionalProp: value }),
+};
+```
+
+### Ternary Chain for Multiple Conditions
+
+```typescript
+const priority = score > 90 ? "high" : score > 70 ? "medium" : "low";
+```
+
+### Readonly Types for Function Parameters
+
+```typescript
+export const calculateTeamGprRank = (
+  leaguePlayers: readonly (PlayerWithScores | null | undefined)[],
+  myTeamId: string | null | undefined
+): number | null => {
+  // ...
+};
+```