Add files using upload-large-folder tool

tasks/notion/easy/computer_science_student_dashboard/simple__code_snippets_go/description.md

@@ -0,0 +1,27 @@
+Find the page named "Computer Science Student Dashboard" and extend the **Code Snippets** section with Go content.
+
+**Task Requirements:**
+1. Add a bold paragraph that contains exactly the text `Go` to mark the start of the Go snippets.
+2. Directly under that heading, add three code blocks configured with `language` set to **go**:
+   a. **Basic Go program** – Caption must be `Basic Go program` and the code content must be exactly:
+   ```go
+   package main
+
+   import "fmt"
+
+   func main() {
+       fmt.Println("Hello, World!")
+   }
+   ```
+   b. **For loop in Go** – Caption must be `For loop in Go` and the code content must be exactly:
+   ```go
+   for i := 0; i < 5; i++ {
+       fmt.Println(i)
+   }
+   ```
+   c. **Function definition in Go** – Caption must be `Function definition in Go` and the code content must be exactly:
+   ```go
+   func add(a, b int) int {
+       return a + b
+   }
+   ```

tasks/notion/easy/computer_science_student_dashboard/simple__code_snippets_go/meta.json

@@ -0,0 +1,24 @@
+{
+  "task_id": "simple__code_snippets_go",
+  "task_name": "Simple Code Snippets Go",
+  "category_id": "computer_science_student_dashboard",
+  "category_name": "Computer Science Student Dashboard",
+  "description": "Add a new Go column to the Code Snippets section between Python and JavaScript columns.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "content organization",
+    "visual formatting",
+    "template population"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Computer-Science-Student-Dashboard-23e81626b6d78083b787d3c832b02ef4",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/computer-science-student-dashboard"
+  }
+}

tasks/notion/easy/computer_science_student_dashboard/simple__code_snippets_go/verify.py

@@ -0,0 +1,125 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+# Expected code blocks (language=go)
+EXPECTED_CODE_BLOCKS = [
+    {
+        "caption": "Basic Go program",
+        "code": (
+            'package main\n\nimport "fmt"\n\nfunc main() {\n    fmt.Println("Hello, World!")\n}'
+        ),
+    },
+    {
+        "caption": "For loop in Go",
+        "code": ("for i := 0; i < 5; i++ {\n    fmt.Println(i)\n}"),
+    },
+    {
+        "caption": "Function definition in Go",
+        "code": ("func add(a, b int) int {\n    return a + b\n}"),
+    },
+]
+
+HEADER_TEXT = "Go"
+
+
+def _normalize(text: str) -> str:
+    """Remove trailing spaces on each line and strip leading/trailing blank lines."""
+    return "\n".join(line.rstrip() for line in text.strip().splitlines())
+
+
+def _find_page(notion: Client, main_id: str | None) -> str | None:
+    """Return a page_id to verify against or None if not found."""
+    page_id = None
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(
+            notion, main_id
+        )
+        if found_id and object_type == "page":
+            page_id = found_id
+    if not page_id:
+        page_id = notion_utils.find_page(notion, "Computer Science Student Dashboard")
+    return page_id
+
+
+def _has_bold_header_text(block, text: str) -> bool:
+    """Generic bold header/paragraph check for a given text."""
+    block_type = block.get("type")
+    if block_type not in {"paragraph", "heading_1", "heading_2", "heading_3"}:
+        return False
+    rich_text_list = block.get(block_type, {}).get("rich_text", [])
+    if not rich_text_list:
+        return False
+    plain = "".join(rt.get("plain_text", "") for rt in rich_text_list).strip()
+    if plain != text:
+        return False
+    return any(rt.get("annotations", {}).get("bold", False) for rt in rich_text_list)
+
+
+def _collect_code_blocks(blocks):
+    """Return list of (code_content, caption) tuples for code blocks with language 'go'."""
+    collected = []
+    for block in blocks:
+        if block.get("type") != "code":
+            continue
+        code_data = block.get("code", {})
+        if code_data.get("language") != "go":
+            continue
+        code_plain = "".join(
+            rt.get("plain_text", "") for rt in code_data.get("rich_text", [])
+        )
+        caption_plain = "".join(
+            rt.get("plain_text", "") for rt in code_data.get("caption", [])
+        )
+        collected.append((code_plain, caption_plain))
+    return collected
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    page_id = _find_page(notion, main_id)
+    if not page_id:
+        print("Error: Target page not found.", file=sys.stderr)
+        return False
+
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+
+    # Verify header
+    header_ok = any(_has_bold_header_text(b, HEADER_TEXT) for b in all_blocks)
+    if not header_ok:
+        print("Failure: Bold header 'Go' not found.", file=sys.stderr)
+        return False
+
+    # Verify code blocks
+    code_blocks_found = _collect_code_blocks(all_blocks)
+
+    remaining = EXPECTED_CODE_BLOCKS.copy()
+    for code, caption in code_blocks_found:
+        norm_code = _normalize(code)
+        for expected in remaining:
+            if (
+                _normalize(expected["code"]) == norm_code
+                and expected["caption"] == caption
+            ):
+                remaining.remove(expected)
+                break
+    if remaining:
+        missing = ", ".join(exp["caption"] for exp in remaining)
+        print(
+            f"Failure: Missing or incorrect Go code blocks: {missing}", file=sys.stderr
+        )
+        return False
+
+    print(
+        "Success: Verified Go header and required Go code blocks."
+    )
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    sys.exit(0 if verify(notion, main_id) else 1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/computer_science_student_dashboard/simple__study_session_tracker/description.md

@@ -0,0 +1,4 @@
+Create a new study-session entry on the **Computer Science Student Dashboard** page.
+
+1. Locate the ☑️ Habit tracker section of the page.
+2. **Insert a new date mention** for `2025-01-29` immediately **after the existing `2022-09-02` items but before the divider block** that follows them. Match the formatting of the existing dates (bold text with a Notion date mention).

tasks/notion/easy/computer_science_student_dashboard/simple__study_session_tracker/meta.json

@@ -0,0 +1,24 @@
+{
+  "task_id": "simple__study_session_tracker",
+  "task_name": "Simple Study Session Tracker",
+  "category_id": "computer_science_student_dashboard",
+  "category_name": "Computer Science Student Dashboard",
+  "description": "Create a new study-session entry in the Habit tracker section with four unchecked to-do items.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "content organization",
+    "visual formatting",
+    "status tracking"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Computer-Science-Student-Dashboard-23e81626b6d78083b787d3c832b02ef4",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/computer-science-student-dashboard"
+  }
+}

tasks/notion/easy/computer_science_student_dashboard/simple__study_session_tracker/verify.py

@@ -0,0 +1,132 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Verify that the new study-session entry for 2025-01-29 was added correctly.
+
+    The script checks that:
+    1. A bold date-mention with start=2025-01-29 exists.
+    2. The mention sits after the 2022-09-02 section but before the divider that originally
+       followed that section.
+    """
+
+    # ---------------------------------------------------------------------
+    # Locate the main page -------------------------------------------------
+    # ---------------------------------------------------------------------
+    page_id: str | None = None
+
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(
+            notion, main_id
+        )
+        if found_id and object_type == "page":
+            page_id = found_id
+
+    if not page_id:
+        page_id = notion_utils.find_page(notion, "Computer Science Student Dashboard")
+
+    if not page_id:
+        print(
+            "Error: Page 'Computer Science Student Dashboard' not found.",
+            file=sys.stderr,
+        )
+        return False
+
+    # ---------------------------------------------------------------------
+    # Fetch all blocks under the page (flattened order) --------------------
+    # ---------------------------------------------------------------------
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+
+    # ---------------------------------------------------------------------
+    # Locate reference blocks ---------------------------------------------
+    # ---------------------------------------------------------------------
+    TARGET_DATE = "2025-01-29"
+    PREVIOUS_DATE = "2022-09-02"
+
+    index_previous_date: int | None = None
+    index_new_date: int | None = None
+    index_divider_after_previous: int | None = None
+
+    for idx, block in enumerate(all_blocks):
+        # Divider detection (we care only about the first divider that appears after
+        # the 2022-09-02 block)
+        if block.get("type") == "divider":
+            if index_previous_date is not None and index_divider_after_previous is None:
+                index_divider_after_previous = idx
+
+        # We only need to inspect paragraph blocks that contain a date mention
+        if block.get("type") != "paragraph":
+            continue
+
+        rich_text_list = block["paragraph"].get("rich_text", [])
+        for rt in rich_text_list:
+            if (
+                rt.get("type") != "mention"
+                or rt.get("mention", {}).get("type") != "date"
+            ):
+                continue
+
+            date_start = rt["mention"]["date"].get("start")
+
+            if date_start == PREVIOUS_DATE and index_previous_date is None:
+                index_previous_date = idx
+
+            if date_start == TARGET_DATE and index_new_date is None:
+                index_new_date = idx
+                # (1) Verify bold annotation
+                if not rt.get("annotations", {}).get("bold", False):
+                    print(
+                        "Error: The 2025-01-29 date mention is not bold.",
+                        file=sys.stderr,
+                    )
+                    return False
+
+    # Ensure all reference indices were found
+    if index_previous_date is None:
+        print("Error: Could not locate the 2022-09-02 date section.", file=sys.stderr)
+        return False
+    if index_divider_after_previous is None:
+        print(
+            "Error: Could not locate the divider that follows the 2022-09-02 section.",
+            file=sys.stderr,
+        )
+        return False
+    if index_new_date is None:
+        print(
+            "Error: Could not locate the new 2025-01-29 date mention.", file=sys.stderr
+        )
+        return False
+
+    # (2) Verify ordering
+    if not (index_previous_date < index_new_date < index_divider_after_previous):
+        print(
+            "Error: The 2025-01-29 section is positioned incorrectly.", file=sys.stderr
+        )
+        return False
+
+    # ---------------------------------------------------------------------
+    # Success --------------------------------------------------------------
+    # ---------------------------------------------------------------------
+    print("Success: Date mention for 2025-01-29 added in the correct position.")
+    return True
+
+
+# -------------------------------------------------------------------------
+# Command-line entry-point -------------------------------------------------
+# -------------------------------------------------------------------------
+
+
+def main() -> None:
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/it_trouble_shooting_hub/simple__asset_retirement_migration/description.md

@@ -0,0 +1,11 @@
+Please migrate expiring assets out of the **IT Inventory** database using the simplified checklist below. Your changes will be verified automatically, so match the details exactly.
+
+---
+Task Steps
+1. Inside the **IT Trouble Shooting Hub** page, locate the database named **IT Inventory**.
+2. Collect every page in **IT Inventory** whose **Status** is **Expired** or **To be returned**.
+3. Create a **new full-page database** under the same hub titled **IT Asset Retirement Queue** with exactly these properties (names and types must match):
+   • Serial – title  
+   • Status – select  
+   • Expiration date – date
+4. For every item gathered in step 2, create a page in **IT Asset Retirement Queue**, copy over the Serial, Status, and Expiration date values, then archive the original inventory page once the copy is made.

tasks/notion/easy/it_trouble_shooting_hub/simple__asset_retirement_migration/meta.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "simple__asset_retirement_migration",
+  "task_name": "Simple Asset Retirement Migration",
+  "category_id": "it_trouble_shooting_hub",
+  "category_name": "IT Trouble Shooting Hub",
+  "description": "Restructure the IT Inventory database by migrating expired assets to a new IT Asset Retirement Queue database.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "database manipulation",
+    "automated migration",
+    "conditional filtering",
+    "data aggregation",
+    "report generation"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/It-Trouble-Shooting-Hub-23e81626b6d78020aba7eb65ae1cc2d5",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/it-trouble-shooting-hub"
+  }
+}

tasks/notion/easy/it_trouble_shooting_hub/simple__asset_retirement_migration/verify.py

@@ -0,0 +1,143 @@
+import sys
+from typing import Dict
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def _get_database(root_page_id: str, notion: Client, name: str) -> str | None:
+    """Helper that finds a child database by title inside a page."""
+    return notion_utils.find_database_in_block(notion, root_page_id, name)
+
+
+def _check_property(props: Dict, name: str, expected_type: str) -> bool:
+    if name not in props:
+        print(f"Error: Property '{name}' missing in database.", file=sys.stderr)
+        return False
+    if props[name]["type"] != expected_type:
+        print(
+            f"Error: Property '{name}' expected type '{expected_type}', found '{props[name]['type']}'.",
+            file=sys.stderr,
+        )
+        return False
+    return True
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Verifies that the IT Asset Retirement Queue was created and populated correctly."""
+
+    # -------------------------------------------------------------------------
+    # Resolve the root IT Trouble Shooting Hub page
+    # -------------------------------------------------------------------------
+    root_page_id = None
+    if main_id:
+        found_id, obj_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if found_id and obj_type == "page":
+            root_page_id = found_id
+
+    if not root_page_id:
+        root_page_id = notion_utils.find_page(notion, "IT Trouble Shooting Hub")
+    if not root_page_id:
+        print(
+            "Error: Could not locate the 'IT Trouble Shooting Hub' page.",
+            file=sys.stderr,
+        )
+        return False
+
+    # -------------------------------------------------------------------------
+    # Locate the original and new databases
+    # -------------------------------------------------------------------------
+    inventory_db_id = _get_database(root_page_id, notion, "IT Inventory")
+    if not inventory_db_id:
+        print("Error: 'IT Inventory' database not found.", file=sys.stderr)
+        return False
+
+    retirement_db_id = _get_database(root_page_id, notion, "IT Asset Retirement Queue")
+    if not retirement_db_id:
+        print("Error: 'IT Asset Retirement Queue' database not found.", file=sys.stderr)
+        return False
+
+    # -------------------------------------------------------------------------
+    # Validate schema of the retirement queue database
+    # -------------------------------------------------------------------------
+    retirement_db = notion.databases.retrieve(database_id=retirement_db_id)
+    r_props = retirement_db["properties"]
+
+    required_schema = {
+        "Serial": "title",
+        "Status": "select",
+        "Expiration date": "date",
+    }
+
+    for pname, ptype in required_schema.items():
+        if not _check_property(r_props, pname, ptype):
+            return False
+
+    # -------------------------------------------------------------------------
+    # Validate that inventory items are moved & archived
+    # -------------------------------------------------------------------------
+    expired_filter = {
+        "property": "Status",
+        "select": {"equals": "Expired"},
+    }
+    to_return_filter = {
+        "property": "Status",
+        "select": {"equals": "To be returned"},
+    }
+    compound_filter = {"or": [expired_filter, to_return_filter]}
+
+    # Query for any *active* items that still match these statuses
+    remaining_items = notion.databases.query(
+        database_id=inventory_db_id,
+        filter=compound_filter,
+        archived=False,
+    ).get("results", [])
+
+    if remaining_items:
+        print(
+            f"Error: {len(remaining_items)} 'Expired' / 'To be returned' items still present in IT Inventory.",
+            file=sys.stderr,
+        )
+        return False
+
+    # There should be at least one entry in the retirement queue
+    retirement_pages = notion.databases.query(database_id=retirement_db_id).get(
+        "results", []
+    )
+    expected_serials = {"65XYQ/GB", "36x10PIQ"}
+    if len(retirement_pages) != len(expected_serials):
+        print(
+            f"Error: Expected {len(expected_serials)} retirement pages, found {len(retirement_pages)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    serials_seen = set()
+    for page in retirement_pages:
+        props = page["properties"]
+        # Collect Serial title
+        title_rich = props.get("Serial", {}).get("title", [])
+        serial_val = "".join([t.get("plain_text", "") for t in title_rich]).strip()
+        serials_seen.add(serial_val)
+
+    if serials_seen != expected_serials:
+        print(
+            f"Error: Serial values mismatch. Expected {sorted(expected_serials)}, found {sorted(serials_seen)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("Success: All verification criteria satisfied.")
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/japan_travel_planner/simple__remove_osaka_itinerary/description.md

@@ -0,0 +1 @@
+Go to Japan Travel Planner, and go to the Travel Itineray database, and remove the itinerary in OSAKA after 6 PM (excluding 6 PM) in Day 1 and Day 2.

tasks/notion/easy/japan_travel_planner/simple__remove_osaka_itinerary/meta.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "simple__remove_osaka_itinerary",
+  "task_name": "Simple Remove Osaka Itinerary",
+  "category_id": "japan_travel_planner",
+  "category_name": "Japan Travel Planner",
+  "description": "Remove the itinerary items in Osaka after 6 PM from Day 1 and Day 2 travel schedules.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "conditional filtering",
+    "automated migration"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Japan-Travel-Planner-23181626b6d781c4b6bedb12786b5abe",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/japantravelplanner101"
+  }
+}

tasks/notion/easy/japan_travel_planner/simple__remove_osaka_itinerary/verify.py

@@ -0,0 +1,288 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+def get_page_title(page_result):
+    """Extract title from a page result"""
+    properties = page_result.get('properties', {})
+    name_property = properties.get('Name', {})
+    if name_property.get('type') == 'title':
+        title_array = name_property.get('title', [])
+        if title_array and len(title_array) > 0:
+            return title_array[0].get('plain_text', '')
+    return ''
+
+def get_page_time(page_result):
+    """Extract time from Notes field"""
+    properties = page_result.get('properties', {})
+    notes_property = properties.get('Notes', {})
+    if notes_property.get('type') == 'rich_text':
+        rich_text_array = notes_property.get('rich_text', [])
+        if rich_text_array and len(rich_text_array) > 0:
+            notes_text = rich_text_array[0].get('plain_text', '')
+            return notes_text.strip()
+    return ''
+
+def get_page_group(page_result):
+    """Extract group/location from page"""
+    properties = page_result.get('properties', {})
+    group_property = properties.get('Group', {})
+    if group_property.get('type') == 'select':
+        select = group_property.get('select')
+        if select:
+            return select.get('name', '')
+    return ''
+
+def get_page_day(page_result):
+    """Extract day from page"""
+    properties = page_result.get('properties', {})
+    day_property = properties.get('Day', {})
+    if day_property.get('type') == 'select':
+        select = day_property.get('select')
+        if select:
+            return select.get('name', '')
+    return ''
+
+def parse_time_to_minutes(time_str):
+    """Convert time string to minutes for comparison
+    Returns None if time cannot be parsed"""
+    if not time_str:
+        return None
+    
+    # Clean the time string
+    time_str = time_str.strip().upper()
+    
+    # Remove any text after the time (e.g., "7:30 PM\n" -> "7:30 PM")
+    time_str = time_str.split('\n')[0].strip()
+    
+    # Extract time components
+    try:
+        if 'PM' in time_str:
+            time_part = time_str.replace('PM', '').strip()
+            if ':' in time_part:
+                hours, minutes = time_part.split(':')
+                hours = int(hours)
+                minutes = int(minutes)
+            else:
+                hours = int(time_part)
+                minutes = 0
+            # Convert PM hours (add 12 for PM times except 12 PM)
+            if hours != 12:
+                hours += 12
+            return hours * 60 + minutes
+        elif 'AM' in time_str:
+            time_part = time_str.replace('AM', '').strip()
+            if ':' in time_part:
+                hours, minutes = time_part.split(':')
+                hours = int(hours)
+                minutes = int(minutes)
+            else:
+                hours = int(time_part)
+                minutes = 0
+            # Handle 12 AM (midnight)
+            if hours == 12:
+                hours = 0
+            return hours * 60 + minutes
+    except:
+        return None
+    
+    return None
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """
+    Verifies that all OSAKA events after 6PM have been removed from Day 1 and Day 2 in the Japan Travel Planner.
+    
+    Expected items that should be deleted (all in OSAKA, after 6PM, on Day 1 or Day 2):
+    1. Rikuro's Namba Main Branch - 7 PM (Day 1)
+    2. Shin Sekai "New World" - 8 PM (Day 2)
+    3. Katsudon Chiyomatsu - 7:30 PM (Day 2)
+    4. Ebisubashi Bridge - 9 PM (Day 1)
+    
+    Note: Kuromon Ichiba Market at 6 PM should NOT be deleted (it's at 6PM, not after)
+    Items after 6PM on other days (Day 3-8) should NOT be deleted
+    """
+    
+    # Step 1: Find the main Japan Travel Planner page
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if not found_id or object_type != 'page':
+            print("Error: Japan Travel Planner page not found.", file=sys.stderr)
+            return False
+    else:
+        # Try to find the page by searching
+        found_id = notion_utils.find_page(notion, "Japan Travel Planner")
+        if not found_id:
+            print("Error: Japan Travel Planner page not found.", file=sys.stderr)
+            return False
+    
+    print(f"Found Japan Travel Planner page: {found_id}")
+    
+    # Step 2: Find the Travel Itinerary database
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, found_id)
+    travel_itinerary_db_id = None
+    
+    for block in all_blocks:
+        if block and block.get("type") == "child_database":
+            title = block.get("child_database", {}).get("title", "")
+            if "Travel Itinerary" in title:
+                travel_itinerary_db_id = block.get("id")
+                print(f"Found Travel Itinerary database: {travel_itinerary_db_id}")
+                break
+    
+    if not travel_itinerary_db_id:
+        print("Error: Travel Itinerary database not found", file=sys.stderr)
+        return False
+    
+    # Step 3: Query the database for OSAKA items on Day 1 and Day 2
+    try:
+        query_result = notion.databases.query(
+            database_id=travel_itinerary_db_id,
+            filter={
+                "and": [
+                    {"property": "Group", "select": {"equals": "Osaka"}},
+                    {"or": [
+                        {"property": "Day", "select": {"equals": "Day 1"}},
+                        {"property": "Day", "select": {"equals": "Day 2"}}
+                    ]}
+                ]
+            }
+        )
+    except Exception as e:
+        print(f"Error querying Travel Itinerary database: {e}", file=sys.stderr)
+        return False
+    
+    # Step 4: Check for items that should have been deleted
+    six_pm_minutes = 18 * 60  # 6 PM in minutes (18:00)
+    
+    # Expected deleted items (4 specific items after 6 PM on Day 1 and Day 2)
+    expected_deleted = {
+        "Rikuro's Namba Main Branch": {"time": "7 PM", "day": "Day 1", "found": False},
+        "Shin Sekai \"New World\"": {"time": "8 PM", "day": "Day 2", "found": False},
+        "Katsudon Chiyomatsu": {"time": "7:30 PM", "day": "Day 2", "found": False},
+        "Ebisubashi Bridge": {"time": "9 PM", "day": "Day 1", "found": False}
+    }
+    
+    # Items that should remain (at or before 6 PM)
+    expected_remaining = {
+        "Kuromon Ichiba Market": {"time": "6 PM", "found": False}
+    }
+    
+    osaka_items_after_6pm = []
+    osaka_items_at_or_before_6pm = []
+    
+    # Debug: Show total query results
+    print(f"Debug: Found {len(query_result.get('results', []))} total OSAKA items on Day 1 and Day 2")
+    
+    # Process all OSAKA items on Day 1 and Day 2
+    for page in query_result.get('results', []):
+        page_title = get_page_title(page).strip()
+        page_time = get_page_time(page)
+        page_group = get_page_group(page)
+        page_day = get_page_day(page)
+        
+        if page_group != "Osaka":
+            continue
+        
+        # Parse time to check if after 6 PM
+        time_minutes = parse_time_to_minutes(page_time)
+        
+        if time_minutes is not None and time_minutes > six_pm_minutes:
+            osaka_items_after_6pm.append({
+                "title": page_title,
+                "time": page_time,
+                "day": page_day,
+                "id": page.get('id')
+            })
+            
+            # Check if this is one of the expected deleted items
+            for expected_title, expected_info in expected_deleted.items():
+                # Clean up the titles for comparison
+                clean_page_title = page_title.strip().lower()
+                clean_expected_title = expected_title.strip().lower()
+                
+                # Check for "Rikuro's" or "Rikuro's" (different apostrophe types)
+                if "rikuro" in clean_page_title and "rikuro" in clean_expected_title:
+                    title_match = True
+                elif clean_page_title == clean_expected_title:
+                    title_match = True
+                elif clean_expected_title in clean_page_title or clean_page_title in clean_expected_title:
+                    title_match = True
+                else:
+                    title_match = False
+                    
+                if title_match and page_day == expected_info["day"]:
+                    print(f"Debug: Found '{page_title}' on {page_day} at {page_time} - matches expected '{expected_title}'")
+                    expected_deleted[expected_title]["found"] = True
+                
+        elif time_minutes is not None and time_minutes <= six_pm_minutes:
+            osaka_items_at_or_before_6pm.append({
+                "title": page_title,
+                "time": page_time,
+                "day": page_day,
+                "id": page.get('id')
+            })
+            
+            # Check if this is one of the expected remaining items
+            for expected_title in expected_remaining:
+                if expected_title.lower() in page_title.lower() or page_title.lower() in expected_title.lower():
+                    expected_remaining[expected_title]["found"] = True
+    
+    # Step 5: Verify results
+    print(f"\nVerification Summary:")
+    print(f"=" * 50)
+    
+    all_passed = True
+    
+    # Check that the 4 expected items after 6 PM have been deleted
+    print("\n4 Items that should be deleted (after 6 PM on Day 1 and Day 2):")
+    for item_name, item_info in expected_deleted.items():
+        if item_info["found"]:
+            # If found = True, it means the item still exists (was not deleted)
+            print(f"✗ {item_name} ({item_info['day']}, {item_info['time']}) - Still exists, should be deleted", file=sys.stderr)
+            all_passed = False
+        else:
+            # If found = False, it means the item was deleted correctly
+            print(f"✓ {item_name} ({item_info['day']}, {item_info['time']}) - Correctly deleted")
+    
+    
+    # Check that items at or before 6 PM remain
+    print("\nItems that should remain (at or before 6 PM on Day 1 and Day 2):")
+    for item_name, item_info in expected_remaining.items():
+        if item_info["found"]:
+            print(f"✓ {item_name} ({item_info['time']}) - Correctly retained")
+        else:
+            print(f"✗ {item_name} ({item_info['time']}) - Missing, should not be deleted", file=sys.stderr)
+            all_passed = False
+    
+    # Report any items after 6 PM that still exist
+    if osaka_items_after_6pm:
+        print(f"\n✗ Found {len(osaka_items_after_6pm)} OSAKA item(s) after 6 PM on Day 1/Day 2:", file=sys.stderr)
+        for item in osaka_items_after_6pm:
+            print(f"  - {item['title']} at {item['time']} ({item['day']})", file=sys.stderr)
+    else:
+        print(f"\n✓ No OSAKA items found after 6 PM on Day 1/Day 2 (all correctly deleted)")
+    
+    # Report count summary
+    print(f"\nCount Summary:")
+    print(f"- OSAKA items after 6 PM on Day 1/Day 2 found: {len(osaka_items_after_6pm)} (should be 0)")
+    print(f"- OSAKA items at/before 6 PM on Day 1/Day 2 found: {len(osaka_items_at_or_before_6pm)}")
+    print(f"- Expected deletions verified: {sum(1 for item in expected_deleted.values() if not item['found'])}/4")
+    
+    return all_passed
+
+def main():
+    """
+    Executes the verification process and exits with a status code.
+    """
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    
+    if verify(notion, main_id):
+        print("\nVerification passed: All 4 required OSAKA events after 6 PM on Day 1 and Day 2 have been removed")
+        sys.exit(0)
+    else:
+        print("\nVerification failed: Some OSAKA events after 6 PM on Day 1/Day 2 still exist")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/online_resume/simple__skills_development_tracker/description.md

@@ -0,0 +1,19 @@
+Create a comprehensive skills audit system by performing the following tasks:
+
+**Task Requirements:**
+1. Create a new database named "Skills Development Tracker" as a child database in the main resume page with the following properties:
+   - Name (title property)
+   - Current Skill (relation to Skills database)
+   - Current Proficiency (rollup from related skill's "Skill Level" property)
+   - Target Proficiency (number property with format "percent")
+   - Gap (formula: Target Proficiency - Current Proficiency)
+   - Learning Resources (rich text property)
+   - Progress Notes (rich text property)
+
+2. Populate the Skills Development Tracker database with entries for all skills that have a proficiency level below 70% (0.7):
+   - For each qualifying skill, create an entry with:
+     - Name: "[Skill Name] Development Plan"
+     - Link to the corresponding skill in Skills database
+     - Target Proficiency: Set to Current + 25% (capped at 95%)
+     - Learning Resources: "Online courses and practice projects"
+     - Progress Notes: "Initial assessment completed"

tasks/notion/easy/online_resume/simple__skills_development_tracker/meta.json

@@ -0,0 +1,27 @@
+{
+  "task_id": "simple__skills_development_tracker",
+  "task_name": "Simple Skills Development Tracker",
+  "category_id": "online_resume",
+  "category_name": "Online Resume",
+  "description": "Create a comprehensive skills audit system with development tracking for skills below 70% proficiency.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "database manipulation",
+    "cross-reference linking",
+    "conditional filtering",
+    "data aggregation",
+    "template population",
+    "visual formatting"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Online-Resume-23181626b6d781159faaeb5eadaf612e",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/online-resume"
+  }
+}

tasks/notion/easy/online_resume/simple__skills_development_tracker/verify.py

@@ -0,0 +1,206 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """
+    Verifies that the Skills Development Tracker database was created correctly.
+    """
+    page_id = None
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(
+            notion, main_id
+        )
+        if found_id and object_type == "page":
+            page_id = found_id
+
+    if not page_id:
+        page_id = notion_utils.find_page(notion, "New Online Resume")
+    if not page_id:
+        print("Error: Page 'New Online Resume' not found.", file=sys.stderr)
+        return False
+
+    # Step 1: Verify Skills Development Tracker database exists
+    tracker_db_id = notion_utils.find_database_in_block(
+        notion, page_id, "Skills Development Tracker"
+    )
+    if not tracker_db_id:
+        print(
+            "Error: Database 'Skills Development Tracker' not found.", file=sys.stderr
+        )
+        return False
+
+    # Step 2: Verify database schema
+    try:
+        db_info = notion.databases.retrieve(database_id=tracker_db_id)
+        properties = db_info.get("properties", {})
+
+        # Check required properties
+        required_props = {
+            "Name": "title",
+            "Current Skill": "relation",
+            "Current Proficiency": "rollup",
+            "Target Proficiency": "number",
+            "Gap": "formula",
+            "Learning Resources": "rich_text",
+            "Progress Notes": "rich_text",
+        }
+
+        for prop_name, expected_type in required_props.items():
+            if prop_name not in properties:
+                print(
+                    f"Error: Property '{prop_name}' not found in database.",
+                    file=sys.stderr,
+                )
+                return False
+            if properties[prop_name]["type"] != expected_type:
+                print(
+                    f"Error: Property '{prop_name}' has incorrect type. Expected '{expected_type}', got '{properties[prop_name]['type']}'.",
+                    file=sys.stderr,
+                )
+                return False
+
+        # Verify Target Proficiency is percent format
+        if (
+            properties["Target Proficiency"].get("number", {}).get("format")
+            != "percent"
+        ):
+            print(
+                "Error: Target Proficiency should have 'percent' format.",
+                file=sys.stderr,
+            )
+            return False
+
+    except Exception as e:
+        print(f"Error retrieving database info: {e}", file=sys.stderr)
+        return False
+
+    # Step 3: Get Skills database to check entries
+    skills_db_id = notion_utils.find_database_in_block(notion, page_id, "Skills")
+    if not skills_db_id:
+        print("Error: Skills database not found.", file=sys.stderr)
+        return False
+
+    # Get all skills with proficiency < 70%
+    skills_below_70 = []
+    try:
+        skills_results = notion.databases.query(database_id=skills_db_id).get(
+            "results", []
+        )
+        for skill in skills_results:
+            skill_level = (
+                skill.get("properties", {}).get("Skill Level", {}).get("number", 1.0)
+            )
+            if skill_level < 0.7:
+                skill_name = (
+                    skill.get("properties", {}).get("Skill", {}).get("title", [])
+                )
+                if skill_name:
+                    skill_name_text = skill_name[0].get("text", {}).get("content", "")
+                    skills_below_70.append(
+                        {
+                            "name": skill_name_text,
+                            "id": skill["id"],
+                            "level": skill_level,
+                        }
+                    )
+    except Exception as e:
+        print(f"Error querying Skills database: {e}", file=sys.stderr)
+        return False
+
+    if not skills_below_70:
+        print("Warning: No skills found with proficiency below 70%.", file=sys.stderr)
+        # This might be OK if all skills are above 70%
+
+    # Step 4: Verify entries in Skills Development Tracker
+    try:
+        tracker_results = notion.databases.query(database_id=tracker_db_id).get(
+            "results", []
+        )
+
+        # Check that we have entries for skills below 70%
+        if len(skills_below_70) > 0 and len(tracker_results) == 0:
+            print(
+                "Error: No entries found in Skills Development Tracker database.",
+                file=sys.stderr,
+            )
+            return False
+
+        # Verify each entry
+        for entry in tracker_results:
+            props = entry.get("properties", {})
+
+            # Check name format
+            name_prop = props.get("Name", {}).get("title", [])
+            if not name_prop:
+                print("Error: Entry missing Name property.", file=sys.stderr)
+                return False
+            name_text = name_prop[0].get("text", {}).get("content", "")
+            if not name_text.endswith(" Development Plan"):
+                print(
+                    f"Error: Entry name '{name_text}' doesn't follow expected format.",
+                    file=sys.stderr,
+                )
+                return False
+
+            # Check relation to Skills database
+            skill_relation = props.get("Current Skill", {}).get("relation", [])
+            if not skill_relation:
+                print(
+                    f"Error: Entry '{name_text}' missing Current Skill relation.",
+                    file=sys.stderr,
+                )
+                return False
+
+            # Check Target Proficiency (should be set)
+            target_prof = props.get("Target Proficiency", {}).get("number")
+            if target_prof is None:
+                print(
+                    f"Error: Entry '{name_text}' missing Target Proficiency.",
+                    file=sys.stderr,
+                )
+                return False
+
+            # Check Learning Resources
+            learning_resources = props.get("Learning Resources", {}).get(
+                "rich_text", []
+            )
+            if not learning_resources:
+                print(
+                    f"Error: Entry '{name_text}' missing Learning Resources.",
+                    file=sys.stderr,
+                )
+                return False
+
+            # Check Progress Notes
+            progress_notes = props.get("Progress Notes", {}).get("rich_text", [])
+            if not progress_notes:
+                print(
+                    f"Error: Entry '{name_text}' missing Progress Notes.",
+                    file=sys.stderr,
+                )
+                return False
+
+    except Exception as e:
+        print(f"Error querying Skills Development Tracker: {e}", file=sys.stderr)
+        return False
+
+    print("Success: Skills Development Tracker database verified successfully.")
+    return True
+
+
+def main():
+    """
+    Executes the verification process and exits with a status code.
+    """
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/python_roadmap/simple__expert_level_lessons/description.md

@@ -0,0 +1,30 @@
+# Task: Expert Level Learning Path (Simplified)
+
+## Objective
+Extend the Python Roadmap with a new Expert Level chapter, create a bridge lesson, and add two expert lessons that build on existing material.
+
+## Requirements
+
+### 1. Add the Expert Level chapter
+- **Database**: Chapters
+- **Name**: `Expert Level`
+- **Icon**: 🟣 (purple circle emoji)
+- Make sure it is linked into the roadmap alongside the existing chapters.
+
+### 2. Create the bridge lesson
+Create a lesson that connects advanced material to the new chapter:
+- **Title**: `Advanced Foundations Review`
+- **Status**: Done
+- **Chapter**: Link it to `Expert Level`
+- **Parent item**: Link to the lesson whose title contains "Control" (e.g., "Control Flow")
+- **Sub-items**: Include links to the lessons containing "Decorators" and "Calling API"
+
+### 3. Add two expert lessons
+Add the following entries to the Steps database:
+
+| Lesson Title | Status | Chapter | Parent item | Date |
+|--------------|--------|---------|-------------|------|
+| `Metaprogramming and AST Manipulation` | To Do | Expert Level | Advanced Foundations Review | 2025-09-15 |
+| `Async Concurrency Patterns` | To Do | Expert Level | Calling API | 2025-09-20 |
+
+The lessons must inherit the correct chapter link, parent relationship, and due date as shown above.

tasks/notion/easy/python_roadmap/simple__expert_level_lessons/meta.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "expert_level_lessons",
+  "task_name": "Expert Level Lessons",
+  "category_id": "python_roadmap",
+  "category_name": "Python Roadmap",
+  "description": "Create an Expert Level chapter with sophisticated prerequisite chains and four expert-level lessons.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "database manipulation",
+    "cross-reference linking",
+    "conditional filtering",
+    "status tracking",
+    "template population"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Python-Roadmap-25281626b6d78012bf2bce1fa8711f4d",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/python-roadmap"
+  }
+}

tasks/notion/easy/python_roadmap/simple__expert_level_lessons/verify.py

@@ -0,0 +1,234 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+TARGET_PAGE_TITLE = "Python Roadmap"
+CHAPTER_NAME = "Expert Level"
+CHAPTER_ICON = "🟣"
+BRIDGE_TITLE = "Advanced Foundations Review"
+REQUIRED_SUBITEM_TITLES = ["Decorators", "Calling API"]
+
+LESSON_REQUIREMENTS = [
+    {
+        "title": "Metaprogramming and AST Manipulation",
+        "status": "To Do",
+        "date": "2025-09-15",
+        "parent_title": BRIDGE_TITLE,
+    },
+    {
+        "title": "Async Concurrency Patterns",
+        "status": "To Do",
+        "date": "2025-09-20",
+        "parent_title": "Calling API",
+    },
+]
+
+
+def _get_database_ids(notion: Client, page_id: str) -> tuple[str | None, str | None]:
+    """Return the block IDs for the Chapters and Steps databases on the page."""
+    chapters_db_id = None
+    steps_db_id = None
+
+    blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+    for block in blocks:
+        if block.get("type") != "child_database":
+            continue
+        title = block.get("child_database", {}).get("title", "")
+        if "Chapters" in title and not chapters_db_id:
+            chapters_db_id = block["id"]
+        elif "Steps" in title and not steps_db_id:
+            steps_db_id = block["id"]
+
+    return chapters_db_id, steps_db_id
+
+
+def _query_step_by_title(notion: Client, database_id: str, title: str, *, exact: bool = True):
+    """Return the first step entry matching the given title pattern."""
+    title_filter = {"equals": title} if exact else {"contains": title}
+    response = notion.databases.query(
+        database_id=database_id,
+        filter={"property": "Lessons", "title": title_filter},
+        page_size=5,
+    )
+    results = response.get("results", [])
+    return results[0] if results else None
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Verify the simplified Expert Level learning path setup."""
+    # Resolve the roadmap page.
+    if main_id:
+        page_id, object_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if not page_id or object_type != "page":
+            print("Error: Python Roadmap page not found.", file=sys.stderr)
+            return False
+    else:
+        page_id = notion_utils.find_page(notion, TARGET_PAGE_TITLE)
+        if not page_id:
+            print("Error: Python Roadmap page not found.", file=sys.stderr)
+            return False
+
+    # Locate the Chapters and Steps databases.
+    chapters_db_id, steps_db_id = _get_database_ids(notion, page_id)
+    if not chapters_db_id:
+        print("Error: Chapters database not found on the page.", file=sys.stderr)
+        return False
+    if not steps_db_id:
+        print("Error: Steps database not found on the page.", file=sys.stderr)
+        return False
+
+    # Ensure the Expert Level chapter exists with the purple icon.
+    try:
+        chapter_resp = notion.databases.query(
+            database_id=chapters_db_id,
+            filter={"property": "Name", "title": {"equals": CHAPTER_NAME}},
+            page_size=1,
+        )
+    except Exception as exc:
+        print(f"Error querying Chapters database: {exc}", file=sys.stderr)
+        return False
+
+    results = chapter_resp.get("results", [])
+    if not results:
+        print("Error: Expert Level chapter not found.", file=sys.stderr)
+        return False
+
+    expert_chapter = results[0]
+    expert_chapter_id = expert_chapter["id"]
+    icon = expert_chapter.get("icon") or {}
+    if icon.get("type") != "emoji" or icon.get("emoji") != CHAPTER_ICON:
+        print("Error: Expert Level chapter must use the purple circle emoji icon.", file=sys.stderr)
+        return False
+
+    print("✓ Expert Level chapter exists with the correct icon.")
+
+    # Locate prerequisite lessons (Control Flow, Decorators, Calling API).
+    control_lesson = _query_step_by_title(notion, steps_db_id, "Control", exact=False)
+    if not control_lesson:
+        print("Error: Could not find a lesson containing 'Control' in its title.", file=sys.stderr)
+        return False
+    control_lesson_id = control_lesson["id"]
+
+    prerequisite_ids = {}
+    for title in REQUIRED_SUBITEM_TITLES:
+        lesson = _query_step_by_title(notion, steps_db_id, title, exact=False)
+        if not lesson:
+            print(f"Error: Required lesson containing '{title}' not found.", file=sys.stderr)
+            return False
+        prerequisite_ids[title] = lesson["id"]
+
+    # Verify the bridge lesson.
+    bridge_lesson = _query_step_by_title(notion, steps_db_id, BRIDGE_TITLE, exact=True)
+    if not bridge_lesson:
+        print("Error: Advanced Foundations Review lesson not found.", file=sys.stderr)
+        return False
+
+    status = (bridge_lesson["properties"].get("Status", {}).get("status") or {}).get("name")
+    if status != "Done":
+        print("Error: Advanced Foundations Review must have status 'Done'.", file=sys.stderr)
+        return False
+
+    # Ensure chapter relation includes Expert Level.
+    chapter_rel = bridge_lesson["properties"].get("Chapters", {}).get("relation", [])
+    if not any(rel["id"] == expert_chapter_id for rel in chapter_rel):
+        print("Error: Advanced Foundations Review must link to the Expert Level chapter.", file=sys.stderr)
+        return False
+
+    # Parent item should be the control lesson.
+    parent_rel = bridge_lesson["properties"].get("Parent item", {}).get("relation", [])
+    if not parent_rel or parent_rel[0]["id"] != control_lesson_id:
+        print("Error: Advanced Foundations Review should use the control lesson as its Parent item.", file=sys.stderr)
+        return False
+
+    # Sub-items must include the required lessons.
+    sub_rel = bridge_lesson["properties"].get("Sub-item", {}).get("relation", [])
+    sub_ids = {rel["id"] for rel in sub_rel}
+    missing = [title for title, rel_id in prerequisite_ids.items() if rel_id not in sub_ids]
+    if missing:
+        print(
+            f"Error: Advanced Foundations Review must include these lessons as sub-items: {', '.join(missing)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("✓ Bridge lesson configured with the correct status, chapter, parent, and sub-items.")
+
+    # Verify the two expert lessons.
+    overall_success = True
+    for spec in LESSON_REQUIREMENTS:
+        lesson = _query_step_by_title(notion, steps_db_id, spec["title"], exact=True)
+        if not lesson:
+            print(f"Error: Lesson '{spec['title']}' not found.", file=sys.stderr)
+            overall_success = False
+            continue
+
+        lesson_ok = True
+
+        # Status check.
+        status_name = (lesson["properties"].get("Status", {}).get("status") or {}).get("name")
+        if status_name != spec["status"]:
+            print(
+                f"Error: Lesson '{spec['title']}' should have status '{spec['status']}', found '{status_name}'.",
+                file=sys.stderr,
+            )
+            lesson_ok = False
+
+        # Chapter relation check.
+        lesson_chapters = lesson["properties"].get("Chapters", {}).get("relation", [])
+        if not any(rel["id"] == expert_chapter_id for rel in lesson_chapters):
+            print(f"Error: Lesson '{spec['title']}' must link to the Expert Level chapter.", file=sys.stderr)
+            lesson_ok = False
+
+        # Parent relation check.
+        parent_title = spec["parent_title"]
+        if parent_title == BRIDGE_TITLE:
+            expected_parent_id = bridge_lesson["id"]
+        else:
+            expected_parent_id = prerequisite_ids.get(parent_title)
+
+        parent_relation = lesson["properties"].get("Parent item", {}).get("relation", [])
+        if not expected_parent_id:
+            print(
+                f"Error: Could not resolve expected parent '{parent_title}' for lesson '{spec['title']}'.",
+                file=sys.stderr,
+            )
+            lesson_ok = False
+        else:
+            if not parent_relation or parent_relation[0]["id"] != expected_parent_id:
+                print(
+                    f"Error: Lesson '{spec['title']}' should have '{parent_title}' as its Parent item.",
+                    file=sys.stderr,
+                )
+                lesson_ok = False
+        # Date check.
+        date_prop = lesson["properties"].get("Date", {}).get("date") or {}
+        if date_prop.get("start") != spec["date"]:
+            print(
+                f"Error: Lesson '{spec['title']}' should use date {spec['date']}, found {date_prop.get('start')}.",
+                file=sys.stderr,
+            )
+            lesson_ok = False
+
+        if lesson_ok:
+            print(f"✓ Lesson '{spec['title']}' has the expected properties.")
+        else:
+            overall_success = False
+
+    if not overall_success:
+        return False
+
+    print("Success: Expert Level chapter, bridge lesson, and expert lessons configured correctly.")
+    return True
+
+
+def main() -> None:
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/self_assessment/simple__faq_column_layout/description.md

@@ -0,0 +1,6 @@
+Navigate to the "Self Assessment" page and reorganize the FAQ toggle content to make it easier to scan.
+
+**Task Requirements:**
+1. Add a column list with two columns inside the FAQ toggle.
+2. Move the first two existing Q&A pairs from the FAQ into the left column.
+3. Move the third existing Q&A pair into the right column, keeping the original heading/paragraph formatting.

tasks/notion/easy/self_assessment/simple__faq_column_layout/meta.json

@@ -0,0 +1,24 @@
+{
+  "task_id": "simple__faq_column_layout",
+  "task_name": "Simple FAQ Column Layout",
+  "category_id": "self_assessment",
+  "category_name": "Self Assessment",
+  "description": "Reorganize the FAQ section content into a two-column layout with balanced Q&A pairs.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "content organization",
+    "visual formatting",
+    "template population"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Self-Assessment-24381626b6d780fe9f56c2ba14ea042d",
+    "stateOriginalUrl": "https://painted-tennis-ebc.notion.site/Self-Assessment-24381626b6d780fe9f56c2ba14ea042d"
+  }
+}

tasks/notion/easy/self_assessment/simple__faq_column_layout/verify.py

@@ -0,0 +1,161 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """
+    Verifies that the FAQ toggle has been properly reorganized with a column list.
+    """
+    # Start from main_id if provided
+    page_id = None
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(
+            notion, main_id
+        )
+        if found_id and object_type == "page":
+            page_id = found_id
+
+    if not page_id:
+        # Try to find the Self Assessment page
+        page_id = notion_utils.find_page(notion, "Self Assessment")
+
+    if not page_id:
+        print("Error: Self Assessment page not found.", file=sys.stderr)
+        return False
+
+    # Get all blocks recursively from the page
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+
+    # Find the FAQ toggle block
+    faq_toggle_block = None
+    faq_toggle_id = None
+    for block in all_blocks:
+        if block.get("type") == "toggle":
+            block_text = notion_utils.get_block_plain_text(block)
+            if "FAQ" in block_text:
+                faq_toggle_block = block
+                faq_toggle_id = block.get("id")
+                print(f"Found FAQ toggle block: {block_text}")
+                break
+
+    if not faq_toggle_block:
+        print("Error: FAQ toggle block not found.", file=sys.stderr)
+        return False
+
+    # Find column_list inside the FAQ toggle
+    column_list_block = None
+    for block in all_blocks:
+        if (
+            block.get("type") == "column_list"
+            and block.get("parent", {}).get("block_id") == faq_toggle_id
+        ):
+            column_list_block = block
+            break
+
+    if not column_list_block:
+        print("Error: No column_list found inside FAQ toggle.", file=sys.stderr)
+        return False
+
+    # Check that there are no Q&A pairs directly under FAQ toggle (outside column_list)
+    direct_faq_children = []
+    for block in all_blocks:
+        if block.get("parent", {}).get("block_id") == faq_toggle_id and block.get(
+            "id"
+        ) != column_list_block.get("id"):
+            direct_faq_children.append(block)
+
+    # Check if any of these are heading_3 or paragraph blocks (Q&A content)
+    for block in direct_faq_children:
+        if block.get("type") in ["heading_3", "paragraph"]:
+            print(
+                f"Error: Found Q&A content outside column_list: {notion_utils.get_block_plain_text(block)[:50]}...",
+                file=sys.stderr,
+            )
+            return False
+
+    # Find the two columns
+    columns = []
+    column_list_id = column_list_block.get("id")
+    for block in all_blocks:
+        if (
+            block.get("type") == "column"
+            and block.get("parent", {}).get("block_id") == column_list_id
+        ):
+            columns.append(block)
+
+    if len(columns) != 2:
+        print(f"Error: Expected 2 columns, found {len(columns)}.", file=sys.stderr)
+        return False
+
+    # Count Q&A pairs in each column
+    qa_counts = []
+    total_pairs = 0
+
+    for i, column in enumerate(columns[:2]):
+        column_id = column.get("id")
+
+        column_blocks = [
+            block
+            for block in all_blocks
+            if block.get("parent", {}).get("block_id") == column_id
+        ]
+
+        qa_pairs = 0
+        j = 0
+        while j < len(column_blocks):
+            if (
+                column_blocks[j].get("type") == "heading_3"
+                and j + 1 < len(column_blocks)
+                and column_blocks[j + 1].get("type") == "paragraph"
+            ):
+                qa_pairs += 1
+                j += 2
+            else:
+                j += 1
+
+        qa_counts.append(qa_pairs)
+        total_pairs += qa_pairs
+        print(f"Column {i + 1}: Found {qa_pairs} Q&A pairs")
+
+    if qa_counts[0] < 2:
+        print(
+            f"Error: Left column should contain at least 2 Q&A pairs, found {qa_counts[0]}.",
+            file=sys.stderr,
+        )
+        return False
+
+    if qa_counts[1] < 1:
+        print(
+            f"Error: Right column should contain at least 1 Q&A pair, found {qa_counts[1]}.",
+            file=sys.stderr,
+        )
+        return False
+
+    if total_pairs < 3:
+        print(
+            f"Error: Expected at least 3 total Q&A pairs across both columns, found {total_pairs}.",
+            file=sys.stderr,
+        )
+        return False
+
+    print(
+        "Success: FAQ toggle organized with two columns holding the existing Q&A pairs (two on the left, one on the right)."
+    )
+    return True
+
+
+def main():
+    """
+    Executes the verification process and exits with a status code.
+    """
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/standard_operating_procedure/simple__section_organization/description.md

@@ -0,0 +1,10 @@
+# Task: Reorganize Standard Operating Procedure Page Sections
+
+## Objective
+Modify the structure of the Standard Operating Procedure page in Notion by updating the order of two sections.
+
+## Requirements
+- Navigate to the Standard Operating Procedure page
+- Swap the positions of the "Terminologies" and "Roles & responsibilities" sections
+- Preserve all content within each section exactly as is
+- Maintain the original formatting and structure of each section

tasks/notion/easy/standard_operating_procedure/simple__section_organization/meta.json

@@ -0,0 +1,24 @@
+{
+  "task_id": "simple__section_organization",
+  "task_name": "Simple Section Organization",
+  "category_id": "standard_operating_procedure",
+  "category_name": "Standard Operating Procedure",
+  "description": "Reorganize the Standard Operating Procedure page by swapping sections and creating a column layout.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "content organization",
+    "cross-reference linking",
+    "visual formatting"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Standard-Operating-Procedure-24381626b6d780a8b678f9e62ae5b152",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/standard-operating-procedure"
+  }
+}

tasks/notion/easy/standard_operating_procedure/simple__section_organization/verify.py

@@ -0,0 +1,76 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+TARGET_PAGE_TITLE = "Standard Operating Procedure"
+ROLES_HEADING = "Roles & responsibilities"
+TERMINOLOGIES_HEADING = "Terminologies"
+
+
+def _find_heading_indices(blocks: list[dict]) -> tuple[int | None, int | None]:
+    """Return the indices of the target headings within the flattened block list."""
+    roles_index = None
+    terminologies_index = None
+
+    for index, block in enumerate(blocks):
+        if block.get("type") != "heading_2":
+            continue
+        rich_text = block.get("heading_2", {}).get("rich_text", [])
+        if not rich_text:
+            continue
+        heading_text = rich_text[0].get("text", {}).get("content", "")
+        if heading_text == ROLES_HEADING and roles_index is None:
+            roles_index = index
+        elif heading_text == TERMINOLOGIES_HEADING and terminologies_index is None:
+            terminologies_index = index
+
+    return roles_index, terminologies_index
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Ensure the Roles & responsibilities section appears before Terminologies."""
+    # Resolve page id.
+    if main_id:
+        page_id, object_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if not page_id or object_type != "page":
+            print("Error: Standard Operating Procedure page not found.", file=sys.stderr)
+            return False
+    else:
+        page_id = notion_utils.find_page(notion, TARGET_PAGE_TITLE)
+        if not page_id:
+            print("Error: Standard Operating Procedure page not found.", file=sys.stderr)
+            return False
+
+    # Fetch all blocks (flattened order from top to bottom).
+    blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+    roles_index, terminologies_index = _find_heading_indices(blocks)
+
+    if roles_index is None:
+        print("Error: 'Roles & responsibilities' section not found.", file=sys.stderr)
+        return False
+    if terminologies_index is None:
+        print("Error: 'Terminologies' section not found.", file=sys.stderr)
+        return False
+
+    if roles_index >= terminologies_index:
+        print(
+            "Error: Sections are not swapped. 'Roles & responsibilities' should appear before 'Terminologies'.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("Success: Section order updated so 'Roles & responsibilities' precedes 'Terminologies'.")
+    return True
+
+
+def main() -> None:
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/team_projects/simple__swap_tasks/description.md

@@ -0,0 +1 @@
+Go to the Team Projects page, find the person responsible for the most tasks (10 in total) and the person responsible for the fewest tasks (3 in total), then swap their assigned tasks.

tasks/notion/easy/team_projects/simple__swap_tasks/meta.json

@@ -0,0 +1,24 @@
+{
+  "task_id": "simple__swap_tasks",
+  "task_name": "Simple Swap Tasks",
+  "category_id": "team_projects",
+  "category_name": "Team Projects",
+  "description": "Find the person responsible for the most and fewest tasks, then swap their assigned tasks.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "data aggregation",
+    "automated migration",
+    "conditional filtering"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Team-Projects-24e81626b6d7809c982fdb7a25825898",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/gantt-chart"
+  }
+}

tasks/notion/easy/team_projects/simple__swap_tasks/verify.py

@@ -0,0 +1,215 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """
+    Verifies that the task assignees have been swapped correctly.
+    Checks:
+    1. "Develop a plan for promotion" and "Evaluate different third-party services" have swapped assignees
+    2. The person with most tasks and person with least tasks have swapped all their tasks
+    """
+    # Step 1: Find the Team Projects page
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if not found_id or object_type != 'page':
+            print("Error: Team Projects page not found.", file=sys.stderr)
+            return False
+    else:
+        # Try to find the page by searching
+        found_id = notion_utils.find_page(notion, "Team Projects")
+        if not found_id:
+            print("Error: Team Projects page not found.", file=sys.stderr)
+            return False
+    
+    # Get all blocks from the page to find database references
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, found_id)
+    
+    # Find Tasks database ID from the page
+    tasks_db_id = None
+    
+    for block in all_blocks:
+        if block and block.get("type") == "child_database":
+            db_title = block.get("child_database", {}).get("title", "")
+            if "Tasks" in db_title:
+                tasks_db_id = block["id"]
+                break
+    
+    if not tasks_db_id:
+        print("Error: Tasks database not found.", file=sys.stderr)
+        return False
+    
+    print("\n📋 Starting verification...")
+    
+    # Step 2: Query all tasks to analyze assignees
+    
+    try:
+        all_tasks_response = notion.databases.query(
+            database_id=tasks_db_id,
+            page_size=100
+        )
+        
+        if not all_tasks_response.get("results"):
+            print("Error: No tasks found in Tasks database.", file=sys.stderr)
+            return False
+        
+        tasks = all_tasks_response["results"]
+        
+    except Exception as e:
+        print(f"Error querying Tasks database: {e}", file=sys.stderr)
+        return False
+    
+    # Step 3: Check specific tasks have swapped assignees
+    
+    develop_plan_task = None
+    evaluate_services_task = None
+    
+    for task in tasks:
+        task_name = task["properties"]["Name"]["title"][0]["text"]["content"]
+        if task_name == "Develop a plan for promotion":
+            develop_plan_task = task
+        elif task_name == "Evaluate different third-party services":
+            evaluate_services_task = task
+    
+    if not develop_plan_task or not evaluate_services_task:
+        print("Error: Could not find both required tasks.", file=sys.stderr)
+        return False
+    
+    # Get assignees for these tasks
+    develop_plan_assignees = develop_plan_task["properties"]["Assigned"]["people"]
+    evaluate_services_assignees = evaluate_services_task["properties"]["Assigned"]["people"]
+    
+    if not develop_plan_assignees or not evaluate_services_assignees:
+        print("Error: Tasks don't have assignees.", file=sys.stderr)
+        return False
+    
+    develop_plan_assignee_id = develop_plan_assignees[0]["id"]
+    evaluate_services_assignee_id = evaluate_services_assignees[0]["id"]
+    
+    # These should be different (swapped)
+    if develop_plan_assignee_id == evaluate_services_assignee_id:
+        print("Error: Tasks should have different assignees after swap.", file=sys.stderr)
+        return False
+    
+    # Step 4: Count tasks per person
+    
+    task_counts = {}
+    unassigned_count = 0
+    
+    for task in tasks:
+        assignees = task["properties"]["Assigned"]["people"]
+        if assignees:
+            assignee_id = assignees[0]["id"]
+            if assignee_id not in task_counts:
+                task_counts[assignee_id] = []
+            task_counts[assignee_id].append(task["properties"]["Name"]["title"][0]["text"]["content"])
+        else:
+            unassigned_count += 1
+    
+    # Sort by task count
+    sorted_assignees = sorted(task_counts.items(), key=lambda x: len(x[1]))
+    
+    if len(sorted_assignees) < 2:
+        print("Error: Need at least 2 people with tasks to verify swap.", file=sys.stderr)
+        return False
+    
+    # Get person with least and most tasks
+    person_with_least = sorted_assignees[0]
+    person_with_most = sorted_assignees[-1]
+    
+    least_id, least_tasks = person_with_least
+    most_id, most_tasks = person_with_most
+    
+    # Step 5: Verify the swap pattern
+    
+    # Original distribution (before swap):
+    # - 5ac96c02-49a4-4320-8de6-b663ba83126b had 3 tasks (least)
+    # - ac7a3bd0-c111-4464-8f45-8a857a1abc8a had 10 tasks (most)
+    
+    # After complete swap, we expect:
+    # - 5ac96c02-49a4-4320-8de6-b663ba83126b should have 10 tasks
+    # - ac7a3bd0-c111-4464-8f45-8a857a1abc8a should have 3 tasks
+    
+    original_least_id = "5ac96c02-49a4-4320-8de6-b663ba83126b"
+    original_most_id = "ac7a3bd0-c111-4464-8f45-8a857a1abc8a"
+    
+    # Check if the swap has been completed
+    swap_completed = False
+    for assignee_id, assignee_tasks in task_counts.items():
+        if assignee_id == original_least_id and len(assignee_tasks) == 10:
+            # Person who had 3 now has 10
+            for other_id, other_tasks in task_counts.items():
+                if other_id == original_most_id and len(other_tasks) == 3:
+                    # Person who had 10 now has 3
+                    swap_completed = True
+                    break
+    
+    # Step 6: Summary
+    print(f"\n📊 Task Distribution:")
+    print(f"  • Total tasks: {len(tasks)}")
+    print(f"  • Assigned tasks: {len(tasks) - unassigned_count}")
+    print(f"  • Unassigned tasks: {unassigned_count}")
+    print(f"  • People with tasks: {len(task_counts)}")
+    print(f"\n  Task counts by person:")
+    for assignee_id, assignee_tasks in sorted_assignees:
+        print(f"    - {assignee_id[:8]}...: {len(assignee_tasks)} tasks")
+    
+    # Step 7: Final verification
+    print("\n🔍 Verification Results:")
+    
+    # Check that the swap has created a significant difference
+    if len(most_tasks) - len(least_tasks) < 5:
+        print(f"Warning: Difference between most and least is only {len(most_tasks) - len(least_tasks)} tasks", file=sys.stderr)
+    
+    # Verify specific expected outcomes
+    verification_passed = True
+    
+    # Check 1: Specific tasks have been swapped
+    specific_tasks_swapped = develop_plan_assignee_id != evaluate_services_assignee_id
+    if specific_tasks_swapped:
+        print("  ✓ Specific tasks have been swapped")
+    else:
+        print("  ✗ Specific tasks were not swapped", file=sys.stderr)
+        verification_passed = False
+    
+    # Check 2: Task distribution shows a complete swap
+    if swap_completed:
+        print("  ✓ Complete task swap verified (3↔10 tasks)")
+    else:
+        # Show actual distribution for debugging
+        person1_tasks = len(task_counts.get(original_least_id, []))
+        person2_tasks = len(task_counts.get(original_most_id, []))
+        print(f"  ✗ Swap incomplete! Expected 5ac96c02→10 tasks, ac7a3bd0→3 tasks", file=sys.stderr)
+        print(f"    Actual: 5ac96c02→{person1_tasks} tasks, ac7a3bd0→{person2_tasks} tasks", file=sys.stderr)
+        verification_passed = False
+    
+    # Check 3: Total task count is preserved
+    total_assigned_tasks = sum(len(tasks) for _, tasks in task_counts.items())
+    expected_total = len(tasks) - unassigned_count
+    
+    if total_assigned_tasks == expected_total:
+        print(f"  ✓ Total task count preserved ({total_assigned_tasks} assigned)")
+    else:
+        print(f"  ✗ Task count mismatch: {total_assigned_tasks} vs {expected_total} expected", file=sys.stderr)
+        verification_passed = False
+    
+    if verification_passed:
+        print("\n✅ All verification checks passed!")
+        return True
+    else:
+        print("\n❌ Verification failed", file=sys.stderr)
+        return False
+
+def main():
+    """
+    Executes the verification process and exits with a status code.
+    """
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

tasks/notion/easy/toronto_guide/simple__change_color/description.md

@@ -0,0 +1,7 @@
+Open the **Toronto Guide** page and refresh the colors of the tags in the **Food** database.
+
+## Requirements
+1. Find and open the Toronto Guide page in Notion.
+2. Locate the *Food* database on that page.
+3. Update every tag in the Food database that is currently pink so that it uses a different color of your choice (any non-pink color is fine).
+4. Do not modify callouts or tags in the other databases.

tasks/notion/easy/toronto_guide/simple__change_color/meta.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "simple__change_color",
+  "task_name": "Simple Change Color",
+  "category_id": "toronto_guide",
+  "category_name": "Toronto Guide",
+  "description": "Navigate to the Toronto Guide page and change all pink-colored elements to different colors.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-11-15",
+  "difficulty": "L1",
+  "tags": [
+    "visual formatting",
+    "conditional filtering"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Toronto-Guide-25281626b6d7802caa7cc394647e901c",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/conquering-toronto-a-destination-guide"
+  }
+}

tasks/notion/easy/toronto_guide/simple__change_color/verify.py

@@ -0,0 +1,100 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+TARGET_PAGE_TITLE = "Toronto Guide"
+FOOD_DATABASE_KEYWORD = "Food"
+TARGET_TAG_NAMES = [
+    "Middle Eastern",
+    "Jamaican",
+    "Indian",
+]
+
+
+def _get_food_database_id(notion: Client, page_id: str) -> str | None:
+    """Return the block ID of the Food database shown on the target page."""
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+    for block in all_blocks:
+        if not block or block.get("type") != "child_database":
+            continue
+        title = block.get("child_database", {}).get("title", "")
+        if FOOD_DATABASE_KEYWORD.lower() in title.lower():
+            return block.get("id")
+    return None
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Check that all target tags in the Food database are no longer pink."""
+    # Resolve the Toronto Guide page ID.
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if not found_id or object_type != "page":
+            print("Error: Toronto Guide page not found.", file=sys.stderr)
+            return False
+        page_id = found_id
+    else:
+        page_id = notion_utils.find_page(notion, TARGET_PAGE_TITLE)
+        if not page_id:
+            print("Error: Toronto Guide page not found.", file=sys.stderr)
+            return False
+
+    # Locate the Food database block.
+    food_db_id = _get_food_database_id(notion, page_id)
+    if not food_db_id:
+        print("Error: Food database not found on the Toronto Guide page.", file=sys.stderr)
+        return False
+
+    # Fetch database definition and inspect tag options.
+    try:
+        db_info = notion.databases.retrieve(database_id=food_db_id)
+    except Exception as exc:
+        print(f"Error: Unable to retrieve Food database ({exc}).", file=sys.stderr)
+        return False
+
+    tags_property = db_info.get("properties", {}).get("Tags", {})
+    if tags_property.get("type") != "multi_select":
+        print("Error: Food database does not have a multi-select Tags property.", file=sys.stderr)
+        return False
+
+    options = tags_property.get("multi_select", {}).get("options", [])
+    remaining_targets = set(TARGET_TAG_NAMES)
+    failures = False
+
+    for option in options:
+        tag_name = option.get("name", "").strip()
+        if tag_name not in remaining_targets:
+            continue
+
+        remaining_targets.discard(tag_name)
+        color = option.get("color")
+        if color == "pink":
+            print(f"Error: Tag '{tag_name}' in Food database is still pink.", file=sys.stderr)
+            failures = True
+        else:
+            print(f"✓ Tag '{tag_name}' color updated to '{color}'.")
+
+    if remaining_targets:
+        print(
+            f"Error: Food tags not found (expected to exist): {sorted(remaining_targets)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    if failures:
+        return False
+
+    print("Success: All Food database tags are now non-pink.")
+    return True
+
+
+def main() -> None:
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/company_in_a_box/employee_onboarding/description.md

@@ -0,0 +1,15 @@
+Build an integrated **Employee Onboarding** system for the existing **Company In A Box** page.
+
+**Task Requirements:**
+1. Create a new **database** titled **Employee Onboarding Checklist** with the following properties *exactly*:
+   • **Employee Name** – title  
+   • **Start Date** – date  
+   • **Department** – select (options: Product, Marketing, Sales, HR, Engineering)  
+
+   Populate this database with **3** sample new-hire pages covering three different departments. Every property in each entry must be filled.
+
+2. Under the top-level page **Company In A Box**, create a new child page titled **Onboarding Hub** containing, in order:
+   1) The **Employee Onboarding Checklist** database embedded at the top.  
+   2) A section headed **Benefits Overview** that includes linked mentions (@-mentions or link-to-page blocks) to **≥ 3** distinct benefit-policy pages from the **Company Wiki** (for example *Benefits policy*, *Vacation Policy*, *Corporate travel*).  
+   3) A section headed **30-Day Timeline** that presents a numbered list with **7** steps covering the first 30 days. **Each step must reference (via @-mention) an existing page or database**.  
+   4) A section headed **Feedback Form** that provides **≥ 3** to-do items for new hires to check off.

tasks/notion/standard/company_in_a_box/employee_onboarding/meta.json

@@ -0,0 +1,25 @@
+{
+  "task_id": "employee_onboarding",
+  "task_name": "Employee Onboarding",
+  "category_id": "company_in_a_box",
+  "category_name": "Company In A Box",
+  "description": "Build an integrated Employee Onboarding system for the existing Company In A Box page with a checklist database, onboarding hub, and feedback form.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "database manipulation",
+    "template population",
+    "cross-reference linking",
+    "status tracking"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Company-In-A-Box-23d81626b6d7800098f3d0e64a706cd8",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/company-in-a-box"
+  }
+}

tasks/notion/standard/company_in_a_box/employee_onboarding/verify.py

@@ -0,0 +1,177 @@
+import sys
+from typing import Dict, Set
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def _check_db_schema(db_props: Dict[str, Dict], required: Dict[str, str]) -> bool:
+    """Return True if every required property exists with the correct type."""
+    for prop_name, expected_type in required.items():
+        if prop_name not in db_props:
+            print(
+                f"Error: Property '{prop_name}' missing from database.", file=sys.stderr
+            )
+            return False
+        actual_type = db_props[prop_name]["type"]
+        if actual_type != expected_type:
+            print(
+                f"Error: Property '{prop_name}' has type '{actual_type}', expected '{expected_type}'.",
+                file=sys.stderr,
+            )
+            return False
+    return True
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:  # noqa: C901
+    """Programmatically verify the onboarding system described in description.md."""
+
+    DB_TITLE = "Employee Onboarding Checklist"
+    HUB_PAGE_TITLE = "Onboarding Hub"
+    DEPARTMENT_OPTIONS: Set[str] = {
+        "Product",
+        "Marketing",
+        "Sales",
+        "HR",
+        "Engineering",
+    }
+    REQUIRED_DB_PROPERTIES = {
+        "Employee Name": "title",
+        "Start Date": "date",
+        "Department": "select",
+    }
+
+    # 1. Locate onboarding database
+    db_id = notion_utils.find_database(notion, DB_TITLE)
+    if not db_id:
+        print(f"Error: Database '{DB_TITLE}' not found.", file=sys.stderr)
+        return False
+
+    try:
+        db_obj = notion.databases.retrieve(database_id=db_id)
+    except Exception as exc:
+        print(f"Error retrieving database: {exc}", file=sys.stderr)
+        return False
+
+    db_props = db_obj.get("properties", {})
+    if not _check_db_schema(db_props, REQUIRED_DB_PROPERTIES):
+        return False
+
+    # Extra: validate select options
+    dept_options = {opt["name"] for opt in db_props["Department"]["select"]["options"]}
+    if not DEPARTMENT_OPTIONS.issubset(dept_options):
+        print(
+            f"Error: Department select options must include {sorted(DEPARTMENT_OPTIONS)}. Current: {sorted(dept_options)}",
+            file=sys.stderr,
+        )
+        return False
+
+    # Check there are at least 3 entries in the database
+    try:
+        db_pages = notion.databases.query(database_id=db_id).get("results", [])
+    except Exception as exc:
+        print(f"Error querying database: {exc}", file=sys.stderr)
+        return False
+    if len(db_pages) < 3:
+        print(
+            "Error: Less than 3 onboarding entries found in the database.",
+            file=sys.stderr,
+        )
+        return False
+
+    # 2. Locate Onboarding Hub page
+    hub_page_id = notion_utils.find_page(notion, HUB_PAGE_TITLE)
+    if not hub_page_id:
+        print(f"Error: Page '{HUB_PAGE_TITLE}' not found.", file=sys.stderr)
+        return False
+
+    # 3. Ensure the onboarding database is embedded in the hub page
+    embedded_db_id = notion_utils.find_database_in_block(notion, hub_page_id, DB_TITLE)
+    if embedded_db_id != db_id:
+        print(
+            "Error: The Employee Onboarding Checklist database is not embedded in the Onboarding Hub page.",
+            file=sys.stderr,
+        )
+        return False
+
+    # 4. Analyse blocks within the hub page for linked mentions, timeline, and feedback form
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, hub_page_id)
+
+    seen_link_targets: Set[str] = set()
+    numbered_list_count = 0
+    todo_count = 0
+
+    for blk in all_blocks:
+        blk_type = blk.get("type")
+
+        # Direct link-to-page blocks
+        if blk_type == "link_to_page":
+            info = blk.get("link_to_page", {})
+            target_id = info.get("page_id") or info.get("database_id")
+            if target_id:
+                seen_link_targets.add(target_id)
+            continue
+
+        # Rich-text mentions inside content blocks
+        if blk_type in {
+            "paragraph",
+            "numbered_list_item",
+            "bulleted_list_item",
+            "to_do",
+        }:
+            content = blk.get(blk_type, {})
+            for rt in content.get("rich_text", []):
+                if rt.get("type") == "mention":
+                    mention = rt.get("mention", {})
+                    if mention.get("type") in {"page", "database"}:
+                        target_id = mention.get("page", {}).get("id") or mention.get(
+                            "database", {}
+                        ).get("id")
+                        if target_id:
+                            seen_link_targets.add(target_id)
+
+        # Count numbered list items
+        if blk_type == "numbered_list_item":
+            numbered_list_count += 1
+
+        # Count to-do items in Feedback Form
+        if blk_type == "to_do":
+            todo_count += 1
+
+    if len(seen_link_targets) < 3:
+        print(
+            "Error: Fewer than 3 linked mentions to benefit policy pages found in the Benefits Overview section.",
+            file=sys.stderr,
+        )
+        return False
+
+    if numbered_list_count < 7:
+        print(
+            "Error: Numbered list contains fewer than 7 steps in the 30-Day Timeline section.",
+            file=sys.stderr,
+        )
+        return False
+
+    if todo_count < 3:
+        print(
+            "Error: Feedback Form section contains fewer than 3 to-do items.",
+            file=sys.stderr,
+        )
+        return False
+
+    print(
+        "Success: Verified Employee Onboarding Checklist database, Onboarding Hub page, and all required sections."
+    )
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/company_in_a_box/goals_restructure/description.md

@@ -0,0 +1,17 @@
+Please restructure the **Current Goals** section on my **Company In A Box** page as follows:
+
+1. **Add a new goal heading** — create a new `heading_3` block titled:
+   
+   `🔄 Digital Transformation Initiative`
+
+2. **Convert all four goal headings to toggles** — the three existing goals
+   * ⚙️ Expand Operations to LATAM  
+   * 🛠️ Push for Enterprise  
+   * 🩶 Boost Employee Engagement  
+   * 🔄 Digital Transformation Initiative  
+
+3. **Move descriptions inside the toggles** — every paragraph or list that originally sat directly under a goal heading should become a **child block** of that heading after it is made toggleable.
+
+4. **Preserve content & order** — apart from the changes above, do **not** modify the text, formatting, or order of existing goal descriptions.
+
+The end result should be a clean **Current Goals** section containing four toggleable goal headings, each with its corresponding details tucked inside.

tasks/notion/standard/company_in_a_box/goals_restructure/meta.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "goals_restructure",
+  "task_name": "Goals Restructure",
+  "category_id": "company_in_a_box",
+  "category_name": "Company In A Box",
+  "description": "Restructure the Current Goals section on the Company In A Box page by adding a new goal heading and converting all goal headings to toggles with content inside.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "content organization",
+    "visual formatting"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Company-In-A-Box-23d81626b6d7800098f3d0e64a706cd8",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/company-in-a-box"
+  }
+}

tasks/notion/standard/company_in_a_box/goals_restructure/verify.py

@@ -0,0 +1,212 @@
+import sys
+from typing import List
+from notion_client import Client
+from tasks.utils import notion_utils
+
+# Expected new goal heading text (including emoji)
+NEW_GOAL_HEADING = "🔄 Digital Transformation Initiative"
+
+# Section title to look for
+GOALS_SECTION_TITLE = "Current Goals"
+
+
+def _plain(block) -> str:
+    """Return concatenated plain text of a block."""
+    return notion_utils.get_block_plain_text(block)
+
+
+# Some Notion rich-text strings may include non-breaking spaces (\xa0) after emoji.
+# Normalize them to plain spaces so text matching is robust.
+def _normalize_string(s: str) -> str:
+    return s.replace("\xa0", " ")
+
+
+def _is_heading(block) -> bool:
+    return block.get("type") in ["heading_1", "heading_2", "heading_3"]
+
+
+def _is_toggle(block) -> bool:
+    """Determine whether a block is a toggle (standard toggle block or toggle-able heading)."""
+    btype = block.get("type")
+    # In our scenario, goal blocks are headings (usually heading_3) marked as toggleable.
+    if btype in ["heading_1", "heading_2", "heading_3"]:
+        heading_data = block.get(btype, {})
+        return heading_data.get("is_toggleable", False)
+    # Some Notion pages may contain classic toggle blocks (type == "toggle"). They are
+    # not expected in this task, but keeping this check allows broader compatibility.
+    return btype == "toggle"
+
+
+def _get_children(notion: Client, block_id: str) -> List[dict]:
+    """Retrieve **direct** children of a block (no pagination handling needed for small test pages)."""
+    try:
+        return notion.blocks.children.list(block_id=block_id).get("results", [])
+    except Exception:
+        return []
+
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """Verifies that the Company in a Box page has been updated per the task requirements."""
+    # 1. Locate the main page
+    page_id = None
+    if main_id:
+        found_id, obj_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if found_id and obj_type == "page":
+            page_id = found_id
+
+    if not page_id:
+        # Try a few case variations just in case
+        for title in [
+            "Company In A Box",
+        ]:
+            page_id = notion_utils.find_page(notion, title)
+            if page_id:
+                break
+
+    if not page_id:
+        print("Error: Could not find the 'Company in a Box' page.", file=sys.stderr)
+        return False
+
+    # 2. Recursively locate the "Current Goals" heading and collect its sibling blocks that
+    #     constitute the section.
+
+    def _fetch_children(bid: str) -> List[dict]:
+        try:
+            return notion.blocks.children.list(block_id=bid).get("results", [])
+        except Exception:
+            return []
+
+    goals_section_blocks: List[dict] = []
+
+    # Breadth-first traversal to find the heading
+    queue = [page_id]
+    found_parent = None
+    found_index = None
+
+    while queue and found_parent is None:
+        parent_id = queue.pop(0)
+        children = _fetch_children(parent_id)
+        for idx, child in enumerate(children):
+            if (
+                _is_heading(child)
+                and GOALS_SECTION_TITLE.lower()
+                in _normalize_string(_plain(child)).lower()
+            ):
+                found_parent = parent_id
+                found_index = idx
+                break
+        # enqueue grandchildren for further search
+        for ch in children:
+            if ch.get("has_children"):
+                queue.append(ch["id"])
+
+    if found_parent is None:
+        print(
+            "Error: Could not find the 'Current Goals' heading anywhere in the page.",
+            file=sys.stderr,
+        )
+        return False
+
+    # Retrieve siblings once more to get the final list and slice after heading.
+    siblings = _fetch_children(found_parent)
+    if found_index is None or found_index >= len(siblings):
+        print(
+            "Error: Internal logic issue when locating Current Goals section.",
+            file=sys.stderr,
+        )
+        return False
+
+    goals_section_blocks = siblings[found_index + 1 :]
+
+    if not goals_section_blocks:
+        print("Error: 'Current Goals' section appears to be empty.", file=sys.stderr)
+        return False
+
+    # 3. Identify toggle blocks that represent goals
+    toggle_blocks = [b for b in goals_section_blocks if _is_toggle(b)]
+
+    if len(toggle_blocks) != 4:
+        print(
+            f"Error: Expected 4 toggle blocks for goals, found {len(toggle_blocks)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    # 4. Ensure the new goal heading exists among the toggles
+    found_new_goal = False
+    for tb in toggle_blocks:
+        if (
+            _normalize_string(NEW_GOAL_HEADING).lower()
+            in _normalize_string(_plain(tb)).lower()
+        ):
+            found_new_goal = True
+            break
+    if not found_new_goal:
+        print(
+            f"Error: Did not find a toggle block with heading '{NEW_GOAL_HEADING}'.",
+            file=sys.stderr,
+        )
+        return False
+
+    # 5. Validate that each toggle has at least one child paragraph/description
+    for tb in toggle_blocks:
+        if (
+            _normalize_string(NEW_GOAL_HEADING).lower()
+            in _normalize_string(_plain(tb)).lower()
+        ):
+            # Skip checking the new goal itself, as it does not have a description yet.
+            continue
+        if not tb.get("has_children", False):
+            print(
+                f"Error: Toggle '{_normalize_string(_plain(tb))}' has no child blocks (description not moved).",
+                file=sys.stderr,
+            )
+            return False
+        children = _get_children(notion, tb["id"])
+        # Ensure there is at least one content child (paragraph, list item, etc.)
+        content_types = {
+            "paragraph",
+            "bulleted_list_item",
+            "numbered_list_item",
+            "to_do",
+            "callout",
+            "quote",
+        }
+        if not any(c.get("type") in content_types for c in children):
+            print(
+                f"Error: Toggle '{_normalize_string(_plain(tb))}' seems to lack any description/content inside it.",
+                file=sys.stderr,
+            )
+            return False
+
+    # 6. Confirm that there are **no** residual heading_3 blocks (non-toggle) for the goals
+    non_toggle_headings = [
+        b
+        for b in goals_section_blocks
+        if b.get("type") == "heading_3" and not _is_toggle(b)
+    ]
+    if non_toggle_headings:
+        titles = [_normalize_string(_plain(b)) for b in non_toggle_headings]
+        print(
+            f"Error: Found heading_3 blocks that were not converted to toggles: {titles}.",
+            file=sys.stderr,
+        )
+        return False
+
+    print(
+        "Success: Verified goal restructuring with new toggle blocks and descriptions."
+    )
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/company_in_a_box/quarterly_review_dashboard/description.md

@@ -0,0 +1,19 @@
+Create a quarterly business review dashboard in Notion based on the existing **Company In A Box** workspace.
+
+**Task Requirements:**
+1. Inside the **Company Wiki** page you will find a sub-page named **Company Goals**. Extract every departmental objective listed under the four departments — **Product**, **Marketing**, **Sales**, and **HR**.
+2. Under the top-level page **Company In A Box**, create a new child page titled **Q4 2024 Business Review Dashboard**.
+3. Inside that new page build the following structure (all parts must exist):
+   1. A single **callout** block near the top that summarises progress toward the three *Current Goals* shown on the main page:
+      • *LATAM expansion*  • *Enterprise push*  • *Employee engagement*  
+      (All three phrases must appear in the callout text.)
+   2. Four separate **section headings** (any heading level) – one for each department (**Product**, **Marketing**, **Sales**, **Human Resources**) – placed below the callout.  Under each heading list that department’s objectives in a progress-tracking format (e.g. to-dos, check-box list). Each objective from the **Company Goals** page must appear at least once.
+   3. Add a **database** named **Action Items** with the following properties *exactly*:
+      • **Task Name** – title
+      • **Department** – select (options: Product, Marketing, Sales, HR)
+      • **Priority** – select (options: High, Medium, Low)
+      • **Status** – status
+      Populate this database with **≥ 5** action-item pages derived from the departmental objectives, making sure every field in each entry is filled:
+       • **Task Name** & **Department** must correctly correspond to the underlying objective/department.
+       • **Priority** and **Status** can be any allowed value, but they must **not** be left empty.
+4. Keep the overall visual style consistent with the existing wiki (use headings, dividers, etc.).

tasks/notion/standard/company_in_a_box/quarterly_review_dashboard/meta.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "quarterly_review_dashboard",
+  "task_name": "Quarterly Review Dashboard",
+  "category_id": "company_in_a_box",
+  "category_name": "Company In A Box",
+  "description": "Create a quarterly business review dashboard in Notion based on the existing Company In A Box workspace with department objectives and action items database.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "database manipulation",
+    "data aggregation",
+    "report generation",
+    "status tracking",
+    "template population"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Company-In-A-Box-23d81626b6d7800098f3d0e64a706cd8",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/company-in-a-box"
+  }
+}

tasks/notion/standard/company_in_a_box/quarterly_review_dashboard/verify.py

@@ -0,0 +1,202 @@
+import sys
+from typing import List
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def _contains_keywords(text: str, keywords: List[str]) -> bool:
+    lowered = text.lower()
+    return all(kw.lower() in lowered for kw in keywords)
+
+
+def verify(notion: Client, main_id: str = None) -> bool:
+    """Programmatically verify that the dashboard page and its contents meet the
+    requirements described in description.md.
+    """
+    DASHBOARD_TITLE = "Q4 2024 Business Review Dashboard"
+    PARENT_PAGE_TITLE = "Company In A Box"
+    CALL_OUT_KEYWORDS = ["latam", "enterprise", "employee engagement"]
+    DEPARTMENTS = ["Product", "Marketing", "Sales", "Human Resources"]
+    REQUIRED_DB_PROPERTIES = {
+        "Task Name": "title",
+        "Department": "select",
+        "Priority": "select",
+        "Status": "status",
+    }
+    PRIORITY_OPTIONS = {"High", "Medium", "Low"}
+
+    # 1. Locate the dashboard page
+    page_id = None
+    if main_id:
+        found_id, obj_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if found_id and obj_type == "page":
+            page_id = found_id
+
+    if not page_id:
+        page_id = notion_utils.find_page(notion, DASHBOARD_TITLE)
+
+    if not page_id:
+        print(f"Error: Page '{DASHBOARD_TITLE}' not found.", file=sys.stderr)
+        return False
+
+    # Optional: ensure it is a child of Company In A Box
+    try:
+        page_obj = notion.pages.retrieve(page_id=page_id)
+        parent_id = page_obj.get("parent", {}).get("page_id")
+        if parent_id:
+            parent_page = notion.pages.retrieve(page_id=parent_id)
+            parent_title_rt = (
+                parent_page.get("properties", {}).get("title", {}).get("title", [])
+            )
+            parent_title = (
+                parent_title_rt[0].get("plain_text") if parent_title_rt else None
+            )
+            if parent_title != PARENT_PAGE_TITLE:
+                print(
+                    f"Error: Dashboard page is not a direct child of '{PARENT_PAGE_TITLE}'.",
+                    file=sys.stderr,
+                )
+                return False
+    except Exception:
+        pass  # parent check is best-effort only
+
+    # 2. Verify callout with keywords
+    all_blocks = notion_utils.get_all_blocks_recursively(notion, page_id)
+    callout_ok = False
+    for block in all_blocks:
+        if block.get("type") == "callout":
+            callout_text = notion_utils.get_block_plain_text(block)
+            if _contains_keywords(callout_text, CALL_OUT_KEYWORDS):
+                callout_ok = True
+                break
+    if not callout_ok:
+        print(
+            "Error: No callout found that includes all three Current Goal keywords (LATAM, Enterprise, Employee engagement).",
+            file=sys.stderr,
+        )
+        return False
+
+    # 3. Verify department section headings
+    found_depts = set()
+    for block in all_blocks:
+        if block.get("type") in {"heading_1", "heading_2", "heading_3"}:
+            heading_text = notion_utils.get_block_plain_text(block)
+            for dept in DEPARTMENTS:
+                if dept.lower() in heading_text.lower():
+                    found_depts.add(dept)
+    if set(DEPARTMENTS) != found_depts:
+        missing = set(DEPARTMENTS) - found_depts
+        print(
+            f"Error: Missing department headings: {', '.join(missing)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    # 4. Verify Action Items database exists and has correct schema
+    db_id = notion_utils.find_database_in_block(notion, page_id, "Action Items")
+    if not db_id:
+        print(
+            "Error: Database 'Action Items' not found on the dashboard.",
+            file=sys.stderr,
+        )
+        return False
+
+    try:
+        db = notion.databases.retrieve(database_id=db_id)
+    except Exception as exc:
+        print(f"Error: Unable to retrieve database: {exc}", file=sys.stderr)
+        return False
+
+    db_props = db.get("properties", {})
+    for prop_name, expected_type in REQUIRED_DB_PROPERTIES.items():
+        if prop_name not in db_props:
+            print(
+                f"Error: Property '{prop_name}' missing from database.", file=sys.stderr
+            )
+            return False
+        actual_type = db_props[prop_name]["type"]
+        if isinstance(expected_type, list):
+            if actual_type not in expected_type:
+                print(
+                    f"Error: Property '{prop_name}' has type '{actual_type}', expected one of {expected_type}.",
+                    file=sys.stderr,
+                )
+                return False
+        else:
+            if actual_type != expected_type:
+                print(
+                    f"Error: Property '{prop_name}' has type '{actual_type}', expected '{expected_type}'.",
+                    file=sys.stderr,
+                )
+                return False
+        # Extra check for Priority options
+        if prop_name == "Priority":
+            options = {opt["name"] for opt in db_props[prop_name]["select"]["options"]}
+            if not PRIORITY_OPTIONS.issubset(options):
+                print(
+                    f"Error: Priority property options must include High/Medium/Low. Current options: {options}",
+                    file=sys.stderr,
+                )
+                return False
+
+    # 5. Verify at least 5 action items exist
+    try:
+        pages = notion.databases.query(database_id=db_id).get("results", [])
+    except Exception as exc:
+        print(f"Error querying database pages: {exc}", file=sys.stderr)
+        return False
+
+    if len(pages) < 5:
+        print("Error: Database contains fewer than 5 action items.", file=sys.stderr)
+        return False
+
+    # Optional: Verify Department values valid
+    for page in pages:
+        props = page.get("properties", {})
+
+        # Task Name must be non-empty
+        title_rt = props.get("Task Name", {}).get("title", [])
+        task_name = title_rt[0].get("plain_text") if title_rt else ""
+        if not task_name.strip():
+            print(
+                f"Error: Action item '{page.get('id')}' is missing a Task Name.",
+                file=sys.stderr,
+            )
+            return False
+
+        # Department must be valid
+        dept_select = props.get("Department", {}).get("select", {}).get("name")
+        if not dept_select or dept_select not in DEPARTMENTS:
+            print(
+                f"Error: Action item '{page.get('id')}' has invalid or missing Department value.",
+                file=sys.stderr,
+            )
+            return False
+
+        # Priority and Status must be set (any value)
+        priority_val = props.get("Priority", {}).get("select", {}).get("name")
+        status_val = props.get("Status", {}).get("status", {}).get("name")
+        if not priority_val or not status_val:
+            print(
+                f"Error: Action item '{page.get('id')}' must have both Priority and Status set.",
+                file=sys.stderr,
+            )
+            return False
+
+    print(
+        "Success: Verified Business Review Dashboard, departmental sections, callout, and Action Items database with ≥5 entries."
+    )
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/it_trouble_shooting_hub/asset_retirement_migration/description.md

@@ -0,0 +1,25 @@
+Please restructure the **IT Inventory** database as described below. Your automation will be checked by an automated script, so follow every detail exactly.
+
+---
+Task Steps
+1. Inside the **IT Trouble Shooting Hub** page, locate the database named **IT Inventory**.
+2. Query this database and collect every page whose **Status** property is **Expired** or **To be returned**.
+3. Create a **new full-page database** directly under the same IT Trouble Shooting Hub page called **IT Asset Retirement Queue**.
+4. Configure this new database so that it contains **exactly** the following properties (spellings and types must match):
+   • Serial – title  
+   • Tags – multi_select  
+   • Status – select  
+   • Vendor – select  
+   • Expiration date – date  
+   • Retirement Reason – select with option set { **Expired License**, **Hardware Obsolete**, **Security Risk**, **User Offboarding** }
+5. For every inventory item gathered in step2:
+   a. Create a corresponding page in **IT Asset Retirement Queue** and copy over the values of the Serial, Tags, Status, Vendor and Expiration date properties.  
+   b. Set **Retirement Reason** to one of the four options above (choose the most appropriate).  
+   c. Archive the original inventory page **after** the new page has been created.
+6. After all items are migrated:
+   a. Update the **description** of the **IT Asset Retirement Queue** database so it is **exactly** `AUTO-GENERATED MIGRATION COMPLETED` (no additional text).
+   b. Create a new page under **IT Trouble Shooting Hub** titled **Retirement Migration Log**. Inside this page, add a **callout block** whose text follows the exact pattern:
+
+      `Successfully migrated <N> assets to the retirement queue on 2025-03-24.`
+
+      • `<N>` is the total number of items moved.

tasks/notion/standard/it_trouble_shooting_hub/asset_retirement_migration/meta.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "asset_retirement_migration",
+  "task_name": "Asset Retirement Migration",
+  "category_id": "it_trouble_shooting_hub",
+  "category_name": "IT Trouble Shooting Hub",
+  "description": "Restructure the IT Inventory database by migrating expired assets to a new IT Asset Retirement Queue database.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "database manipulation",
+    "automated migration",
+    "conditional filtering",
+    "data aggregation",
+    "report generation"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/It-Trouble-Shooting-Hub-23e81626b6d78020aba7eb65ae1cc2d5",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/it-trouble-shooting-hub"
+  }
+}

tasks/notion/standard/it_trouble_shooting_hub/asset_retirement_migration/verify.py

@@ -0,0 +1,226 @@
+import sys
+from typing import Dict, Set
+from notion_client import Client
+from tasks.utils import notion_utils
+
+
+def _get_database(root_page_id: str, notion: Client, name: str) -> str | None:
+    """Helper that finds a child database by title inside a page."""
+    return notion_utils.find_database_in_block(notion, root_page_id, name)
+
+
+def _check_property(props: Dict, name: str, expected_type: str) -> bool:
+    if name not in props:
+        print(f"Error: Property '{name}' missing in database.", file=sys.stderr)
+        return False
+    if props[name]["type"] != expected_type:
+        print(
+            f"Error: Property '{name}' expected type '{expected_type}', found '{props[name]['type']}'.",
+            file=sys.stderr,
+        )
+        return False
+    return True
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Verifies that the IT Asset Retirement Queue was created and populated correctly."""
+
+    # -------------------------------------------------------------------------
+    # Resolve the root IT Trouble Shooting Hub page
+    # -------------------------------------------------------------------------
+    root_page_id = None
+    if main_id:
+        found_id, obj_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if found_id and obj_type == "page":
+            root_page_id = found_id
+
+    if not root_page_id:
+        root_page_id = notion_utils.find_page(notion, "IT Trouble Shooting Hub")
+    if not root_page_id:
+        print(
+            "Error: Could not locate the 'IT Trouble Shooting Hub' page.",
+            file=sys.stderr,
+        )
+        return False
+
+    # -------------------------------------------------------------------------
+    # Locate the original and new databases
+    # -------------------------------------------------------------------------
+    inventory_db_id = _get_database(root_page_id, notion, "IT Inventory")
+    if not inventory_db_id:
+        print("Error: 'IT Inventory' database not found.", file=sys.stderr)
+        return False
+
+    retirement_db_id = _get_database(root_page_id, notion, "IT Asset Retirement Queue")
+    if not retirement_db_id:
+        print("Error: 'IT Asset Retirement Queue' database not found.", file=sys.stderr)
+        return False
+
+    # -------------------------------------------------------------------------
+    # Validate schema of the retirement queue database
+    # -------------------------------------------------------------------------
+    retirement_db = notion.databases.retrieve(database_id=retirement_db_id)
+    r_props = retirement_db["properties"]
+
+    required_schema = {
+        "Serial": "title",
+        "Tags": "multi_select",
+        "Status": "select",
+        "Vendor": "select",
+        "Expiration date": "date",
+        "Retirement Reason": "select",
+    }
+
+    for pname, ptype in required_schema.items():
+        if not _check_property(r_props, pname, ptype):
+            return False
+
+    # Check Retirement Reason options
+    expected_reason_options: Set[str] = {
+        "Expired License",
+        "Hardware Obsolete",
+        "Security Risk",
+        "User Offboarding",
+    }
+    actual_options = {
+        opt["name"] for opt in r_props["Retirement Reason"]["select"]["options"]
+    }
+    if actual_options != expected_reason_options:
+        print(
+            "Error: 'Retirement Reason' select options mismatch.\n"
+            f"Expected: {sorted(expected_reason_options)}\n"
+            f"Found: {sorted(actual_options)}",
+            file=sys.stderr,
+        )
+        return False
+
+    # ---------------------------------------------------------------
+    # Validate database description starts with required phrase
+    # ---------------------------------------------------------------
+    desc_rich = retirement_db.get("description", [])
+    desc_text = "".join([t.get("plain_text", "") for t in desc_rich])
+    required_desc = "AUTO-GENERATED MIGRATION COMPLETED"
+    if desc_text.strip() != required_desc:
+        print(
+            f"Error: Retirement database description must be exactly '{required_desc}'.",
+            file=sys.stderr,
+        )
+        return False
+
+    # -------------------------------------------------------------------------
+    # Validate that inventory items are moved & archived
+    # -------------------------------------------------------------------------
+    expired_filter = {
+        "property": "Status",
+        "select": {"equals": "Expired"},
+    }
+    to_return_filter = {
+        "property": "Status",
+        "select": {"equals": "To be returned"},
+    }
+    compound_filter = {"or": [expired_filter, to_return_filter]}
+
+    # Query for any *active* items that still match these statuses
+    remaining_items = notion.databases.query(
+        database_id=inventory_db_id,
+        filter=compound_filter,
+        archived=False,
+    ).get("results", [])
+
+    if remaining_items:
+        print(
+            f"Error: {len(remaining_items)} 'Expired' / 'To be returned' items still present in IT Inventory.",
+            file=sys.stderr,
+        )
+        return False
+
+    # There should be at least one entry in the retirement queue
+    retirement_pages = notion.databases.query(database_id=retirement_db_id).get(
+        "results", []
+    )
+    expected_serials = {"65XYQ/GB", "36x10PIQ"}
+    if len(retirement_pages) != len(expected_serials):
+        print(
+            f"Error: Expected {len(expected_serials)} retirement pages, found {len(retirement_pages)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    # Each retirement page must have a Retirement Reason
+    serials_seen = set()
+    for page in retirement_pages:
+        props = page["properties"]
+        reason = props.get("Retirement Reason", {}).get("select", {})
+        if not reason or reason.get("name") not in expected_reason_options:
+            print(
+                f"Error: Page {page['id']} missing valid 'Retirement Reason'.",
+                file=sys.stderr,
+            )
+            return False
+
+        # Collect Serial title
+        title_rich = props.get("Serial", {}).get("title", [])
+        serial_val = "".join([t.get("plain_text", "") for t in title_rich]).strip()
+        serials_seen.add(serial_val)
+
+    if serials_seen != expected_serials:
+        print(
+            f"Error: Serial values mismatch. Expected {sorted(expected_serials)}, found {sorted(serials_seen)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    # -----------------------------------------------------------------
+    # Verify the migration log page and callout block contents
+    # -----------------------------------------------------------------
+    log_page_title = "Retirement Migration Log"
+    log_page_id = notion_utils.find_page(notion, log_page_title)
+    if not log_page_id:
+        print(f"Error: Page '{log_page_title}' not found.", file=sys.stderr)
+        return False
+
+    # Search for a callout block with required pattern
+    import re
+
+    callout_pattern = re.compile(
+        r"Successfully migrated (\d+) assets to the retirement queue on 2025-03-24\."
+    )
+    blocks = notion_utils.get_all_blocks_recursively(notion, log_page_id)
+    match_found = False
+    for blk in blocks:
+        if blk.get("type") == "callout":
+            text = notion_utils.get_block_plain_text(blk)
+            m = callout_pattern.search(text)
+            if m:
+                migrated_num = int(m.group(1))
+                if migrated_num == len(expected_serials):
+                    match_found = True
+                else:
+                    print(
+                        f"Error: Callout reports {migrated_num} assets, but {len(retirement_pages)} retirement pages found.",
+                        file=sys.stderr,
+                    )
+                    return False
+                break
+    if not match_found:
+        print(
+            "Error: Required callout block not found in migration log page.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("Success: All verification criteria satisfied.")
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/it_trouble_shooting_hub/security_audit_ticket/description.md

@@ -0,0 +1,21 @@
+Please help me create a comprehensive security audit ticket based on the data already stored in the **IT Trouble Shooting Hub** page.
+
+Your automation should:
+
+1. In the **IT Inventory** database, find every item whose **Expiration date** is **before 2023-07-15**.
+2. In the **IT FAQs** database, look up any FAQ entries that have the **"Security"** tag.
+3. **Create a new page** inside the **IT Requests** database with **exact title**:
+   
+   `Quarterly Security Audit - Expired Assets Review`
+4. Set its **Priority** property to **High**.
+5. Set its **Due** property to **2023-06-22**.
+6. In the page body, add a bullet-list block that enumerates **each expired inventory item**. **Each bullet item must follow this exact text format (including the dashes):**
+
+   `<Serial> - <Tag> - <Recommendation>`
+
+   • `<Serial>` is the item’s Serial value.
+   • `<Tag>` is the first tag assigned to the inventory item (e.g., "Laptop").
+   • `<Recommendation>` is a brief action you suggest based on the security FAQ entry (any text is acceptable).
+
+   Example (do **not** copy):
+   `ABC123 - Laptop - Renew warranty and enable disk encryption`

tasks/notion/standard/it_trouble_shooting_hub/security_audit_ticket/meta.json

@@ -0,0 +1,25 @@
+{
+  "task_id": "security_audit_ticket",
+  "task_name": "Security Audit Ticket",
+  "category_id": "it_trouble_shooting_hub",
+  "category_name": "IT Trouble Shooting Hub",
+  "description": "Create a comprehensive security audit ticket based on expired inventory items and security FAQ entries.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "conditional filtering",
+    "database manipulation",
+    "data aggregation",
+    "report generation"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/It-Trouble-Shooting-Hub-23e81626b6d78020aba7eb65ae1cc2d5",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/it-trouble-shooting-hub"
+  }
+}

tasks/notion/standard/it_trouble_shooting_hub/security_audit_ticket/verify.py

@@ -0,0 +1,176 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+import re
+
+
+def _get_title_text(page_properties: dict) -> str:
+    """Extract the plain text of the first title property from a page."""
+    for prop in page_properties.values():
+        if prop.get("type") == "title":
+            title_rich = prop.get("title", [])
+            if title_rich:
+                return title_rich[0].get("plain_text")
+    return ""
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    """Verify that the automation created the expected security audit ticket."""
+
+    # ----------------------------------------------------------------------------------
+    # Locate the root page (IT Trouble Shooting Hub) either via main_id or by title.
+    # ----------------------------------------------------------------------------------
+    root_page_id = None
+    if main_id:
+        found_id, object_type = notion_utils.find_page_or_database_by_id(
+            notion, main_id
+        )
+        if found_id and object_type == "page":
+            root_page_id = found_id
+
+    if not root_page_id:
+        root_page_id = notion_utils.find_page(notion, "IT Trouble Shooting Hub")
+    if not root_page_id:
+        print(
+            "Error: Could not locate the 'IT Trouble Shooting Hub' page.",
+            file=sys.stderr,
+        )
+        return False
+
+    # ----------------------------------------------------------------------------------
+    # Find the IT Requests database under the root page.
+    # ----------------------------------------------------------------------------------
+    requests_db_id = notion_utils.find_database_in_block(
+        notion, root_page_id, "IT Requests"
+    )
+    if not requests_db_id:
+        print(
+            "Error: 'IT Requests' database not found in the workspace.", file=sys.stderr
+        )
+        return False
+
+    # ----------------------------------------------------------------------------------
+    # Search for the expected ticket inside the IT Requests database.
+    # ----------------------------------------------------------------------------------
+    expected_title = "Quarterly Security Audit - Expired Assets Review"
+    results = notion.databases.query(database_id=requests_db_id).get("results", [])
+
+    target_page = None
+    for page in results:
+        title_text = _get_title_text(page.get("properties", {}))
+        if title_text == expected_title:
+            target_page = page
+            break
+
+    if not target_page:
+        print(
+            f"Failure: Ticket with title '{expected_title}' was not found in 'IT Requests' database.",
+            file=sys.stderr,
+        )
+        return False
+
+    props = target_page.get("properties", {})
+
+    # ----------------------------------------------------------------------------------
+    # Validate Priority property.
+    # ----------------------------------------------------------------------------------
+    priority_value = props.get("Priority", {}).get("select", {}).get("name")
+    if priority_value != "High":
+        print(
+            f"Failure: Expected Priority 'High', found '{priority_value}'.",
+            file=sys.stderr,
+        )
+        return False
+
+    # ----------------------------------------------------------------------------------
+    # Validate Due date property.
+    # ----------------------------------------------------------------------------------
+    due_date_start = props.get("Due", {}).get("date", {}).get("start")
+    expected_due_iso = "2023-06-22"
+    if not due_date_start or not due_date_start.startswith(expected_due_iso):
+        print(
+            f"Failure: Expected Due date '{expected_due_iso}', found '{due_date_start}'.",
+            file=sys.stderr,
+        )
+        return False
+
+    # ----------------------------------------------------------------------------------
+    # Validate the bulleted list contains the correct expired items in required format.
+    # ----------------------------------------------------------------------------------
+    page_id = target_page["id"]
+    blocks = notion.blocks.children.list(block_id=page_id).get("results", [])
+    bullet_texts = [
+        notion_utils.get_block_plain_text(b)
+        for b in blocks
+        if b.get("type") == "bulleted_list_item"
+    ]
+
+    expected_items = {
+        "192371-8910/54": "Computer Accessory",
+        "32x11PIP": "Computer Accessory",
+        "76x87PCY": "Laptop",
+        "36x10PIQ": "Computer Accessory",
+        "65XYQ/GB": "License",
+    }
+
+    if len(bullet_texts) != len(expected_items):
+        print(
+            f"Failure: Expected {len(expected_items)} bullet items, found {len(bullet_texts)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    bullet_pattern = re.compile(r"^\s*(.*?)\s+-\s+(.*?)\s+-\s+(.+?)\s*$")
+    matched = set()
+    for text in bullet_texts:
+        m = bullet_pattern.match(text)
+        if not m:
+            print(
+                f"Failure: Bullet item '{text}' does not follow '<Serial> - <Tag> - <Recommendation>' format.",
+                file=sys.stderr,
+            )
+            return False
+        serial, tag, advice = m.group(1).strip(), m.group(2).strip(), m.group(3).strip()
+        if serial not in expected_items:
+            print(
+                f"Failure: Unexpected Serial '{serial}' found in bullet list.",
+                file=sys.stderr,
+            )
+            return False
+        if expected_items[serial] != tag:
+            print(
+                f"Failure: Serial '{serial}' expected tag '{expected_items[serial]}', found '{tag}'.",
+                file=sys.stderr,
+            )
+            return False
+        if not advice:
+            print(
+                f"Failure: Bullet item for Serial '{serial}' is missing a recommendation/advice.",
+                file=sys.stderr,
+            )
+            return False
+        matched.add(serial)
+
+    if len(matched) != len(expected_items):
+        missing = set(expected_items.keys()) - matched
+        print(
+            f"Failure: Missing bullet items for serials: {', '.join(missing)}.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("Success: All verification criteria satisfied.")
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/it_trouble_shooting_hub/verification_expired_update/description.md

@@ -0,0 +1,17 @@
+**Task Overview**
+
+My IT knowledge base contains pages whose verification status has expired:
+
+**Task Requirements**
+1. Locate the database named **"IT Homepage"** inside the main page **"It Trouble Shooting Hub"**.
+2. Within that database, find every page (except for **"It Inventory"**) where the **Verification** property state contains `expired`.
+3. For **each** expired page:
+   • Insert a **callout block** at the very top (as the first child block) whose rich-text content is:
+     `VERIFICATION EXPIRED - This page needs review and re-verification`
+   • Set the callout’s icon to ⚠️.
+   • Set the callout’s colour to `red_background`.
+4. Create a new entry in the **"IT Requests"** database with:
+   • Title (property **Task name**) **exactly** `Batch Verification Update Required`.
+   • **Priority** set to `High`.
+   • **Status** set to `In progress`.
+   • In the page body add a **bulleted list** where each bullet is a **mention** of the page processed in step 3 (i.e., use the Notion mention object linking to that page).

tasks/notion/standard/it_trouble_shooting_hub/verification_expired_update/meta.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "verification_expired_update",
+  "task_name": "Verification Expired Update",
+  "category_id": "it_trouble_shooting_hub",
+  "category_name": "IT Trouble Shooting Hub",
+  "description": "Update pages with expired verification status by adding warning callouts and creating a batch update request.",
+  "author": "Zijian Wu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "conditional filtering",
+    "visual formatting",
+    "database manipulation",
+    "cross-reference linking",
+    "status tracking"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/It-Trouble-Shooting-Hub-23e81626b6d78020aba7eb65ae1cc2d5",
+    "stateOriginalUrl": "https://www.notion.so/marketplace/templates/it-trouble-shooting-hub"
+  }
+}

tasks/notion/standard/it_trouble_shooting_hub/verification_expired_update/verify.py

@@ -0,0 +1,195 @@
+import sys
+from notion_client import Client
+from tasks.utils import notion_utils
+
+CALL_OUT_TEXT = "VERIFICATION EXPIRED - This page needs review and re-verification"
+CALL_OUT_ICON = "⚠️"
+CALL_OUT_COLOR = "red_background"
+IT_HOMEPAGE_DB_TITLE = "IT Homepage"
+IT_REQUESTS_DB_TITLE = "IT Requests"
+REQUEST_TITLE = "Batch Verification Update Required"
+PRIORITY_HIGH = "High"
+STATUS_IN_PROGRESS = "In progress"
+
+
+def _get_main_page_id(notion: Client, main_id: str | None) -> str | None:
+    """Resolve the main page id starting from CLI arg or by title search."""
+    if main_id:
+        found_id, obj_type = notion_utils.find_page_or_database_by_id(notion, main_id)
+        if found_id and obj_type == "page":
+            return found_id
+    # Fallback to title search (case-insensitive)
+    return notion_utils.find_page(notion, "It Trouble Shooting Hub")
+
+
+def _fetch_database_id(
+    notion: Client, parent_page_id: str, db_title: str
+) -> str | None:
+    """Locate a child database by title inside a given page."""
+    return notion_utils.find_database_in_block(notion, parent_page_id, db_title)
+
+
+def _expired_pages(notion: Client, db_id: str) -> list[dict]:
+    """Return list of page objects with Verification.state == 'expired'."""
+    # Query all pages (API max 100 per call). If many pages expected, iterate.
+    results = notion.databases.query(database_id=db_id).get("results", [])
+    expired = []
+    for page in results:
+        verification_prop = page.get("properties", {}).get("Verification", {})
+        state = verification_prop.get("verification", {}).get("state")
+        # Skip the IT Inventory database entry
+        title_prop = page.get("properties", {}).get("Page", {}).get("title", [])
+        title_text = title_prop[0].get("plain_text") if title_prop else ""
+        if title_text.strip().lower() == "it inventory":
+            continue
+
+        if state and "expired" in state.lower():
+            expired.append(page)
+    return expired
+
+
+def _check_callout_present(notion: Client, page_id: str) -> bool:
+    """Verify the specified callout is the first child block of the page."""
+    children = notion.blocks.children.list(block_id=page_id, page_size=1).get(
+        "results", []
+    )
+    if not children:
+        return False
+    first_block = children[0]
+    if first_block.get("type") != "callout":
+        return False
+    data = first_block.get("callout", {})
+    # Check color
+    if data.get("color") != CALL_OUT_COLOR:
+        return False
+
+    # Check icon
+    icon = data.get("icon", {})
+    if icon.get("type") != "emoji" or icon.get("emoji") != CALL_OUT_ICON:
+        return False
+
+    # Check text content (callout rich text plain text)
+    plain_text = notion_utils.get_block_plain_text(first_block)
+    return CALL_OUT_TEXT in plain_text
+
+
+def _find_request_page(notion: Client, db_id: str) -> dict | None:
+    """Find the IT Request page with the expected title."""
+    # Use a simple search inside database
+    res = notion.databases.query(
+        database_id=db_id,
+        filter={"property": "Task name", "title": {"equals": REQUEST_TITLE}},
+    ).get("results", [])
+    return res[0] if res else None
+
+
+def _check_request_properties(page: dict) -> bool:
+    props = page.get("properties", {})
+    priority = props.get("Priority", {}).get("select", {}).get("name")
+    status = (
+        props.get("Status", {}).get("status", {}).get("name")
+        if props.get("Status", {}).get("status")
+        else props.get("Status", {}).get("select", {}).get("name")
+    )
+    return priority == PRIORITY_HIGH and status == STATUS_IN_PROGRESS
+
+
+def _request_page_contains_mentions(
+    notion: Client, request_page_id: str, expected_page_ids: list[str]
+) -> bool:
+    children = notion.blocks.children.list(block_id=request_page_id, page_size=100).get(
+        "results", []
+    )
+    bullet_blocks = [b for b in children if b.get("type") == "bulleted_list_item"]
+    mentioned_ids: set[str] = set()
+    for block in bullet_blocks:
+        rich_text = block.get("bulleted_list_item", {}).get("rich_text", [])
+        for rt in rich_text:
+            if rt.get("type") == "mention":
+                mention = rt.get("mention", {})
+                if mention.get("type") == "page":
+                    mentioned_ids.add(mention.get("page", {}).get("id"))
+    if len(mentioned_ids) < len(expected_page_ids):
+        return False
+    return all(pid in mentioned_ids for pid in expected_page_ids)
+
+
+def verify(notion: Client, main_id: str | None = None) -> bool:
+    main_page_id = _get_main_page_id(notion, main_id)
+    if not main_page_id:
+        print(
+            "Error: Could not locate the main page 'It Trouble Shooting Hub'.",
+            file=sys.stderr,
+        )
+        return False
+
+    # Locate required databases
+    it_home_db_id = _fetch_database_id(notion, main_page_id, IT_HOMEPAGE_DB_TITLE)
+    it_req_db_id = _fetch_database_id(notion, main_page_id, IT_REQUESTS_DB_TITLE)
+    if not all([it_home_db_id, it_req_db_id]):
+        print(
+            "Error: Required databases not found under the main page.", file=sys.stderr
+        )
+        return False
+
+    # Identify expired pages
+    expired_pages = _expired_pages(notion, it_home_db_id)
+    if not expired_pages:
+        print(
+            "Failure: No expired pages found; expected at least one for this task.",
+            file=sys.stderr,
+        )
+        return False
+
+    # Verify callout on each expired page
+    for pg in expired_pages:
+        pid = pg["id"]
+        if not _check_callout_present(notion, pid):
+            print(
+                f"Failure: Callout missing or incorrect on page {pid}.", file=sys.stderr
+            )
+            return False
+
+    # Verify IT Request entry
+    request_page = _find_request_page(notion, it_req_db_id)
+    if not request_page:
+        print(
+            "Failure: IT Request 'Batch Verification Update Required' not found.",
+            file=sys.stderr,
+        )
+        return False
+    if not _check_request_properties(request_page):
+        print("Failure: Priority or Status incorrect on IT Request.", file=sys.stderr)
+        return False
+
+    # Verify bullet list in IT Request body
+    expired_titles = []
+    for p in expired_pages:
+        title_prop = p.get("properties", {}).get("Page", {}).get("title", [])
+        title_text = title_prop[0].get("plain_text") if title_prop else None
+        if title_text:
+            expired_titles.append(title_text)
+    expected_page_ids = [p["id"] for p in expired_pages]
+    if not _request_page_contains_mentions(
+        notion, request_page["id"], expected_page_ids
+    ):
+        print(
+            "Failure: IT Request body does not contain mentions for all affected pages.",
+            file=sys.stderr,
+        )
+        return False
+
+    print("Success: All verification checks passed.")
+    return True
+
+
+def main():
+    notion = notion_utils.get_notion_client()
+    main_id = sys.argv[1] if len(sys.argv) > 1 else None
+    if verify(notion, main_id):
+        sys.exit(0)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tasks/notion/standard/japan_travel_planner/daily_itinerary_overview/description.md

@@ -0,0 +1,14 @@
+Create a comprehensive daily itinerary overview page to help organize my Japan travel plans. I need you to create a new page called 'Daily Itinerary Overview' as a child of the main Japan Travel Planner page.
+
+**Task Requirements:**
+1. Create a new page titled 'Daily Itinerary Overview' as a child page of the main Japan Travel Planner page
+2. Query the Travel Itinerary database to retrieve all activities
+3. Structure the page with the following specific format:
+   - Add a heading_1 block with text "📅 Daily Itinerary Overview"
+   - Add a heading_2 block with text "📊 Trip Summary"
+   - Under Trip Summary, add a paragraph listing the total number of visited activities
+   - Create heading_2 blocks for "🌅 Day 1", "🌆 Day 2", and "🌃 Day 3"
+   - Under each day heading, list the activities scheduled for that day in to do list
+   - Each activity (use To-do list) should show: Activity Name - City (if available), for example, "Osaka Castle - Osaka". Check it if it's visited.
+4. The summary paragraph must contain the exact text "Total activities visited (from Day 1 to Day 3): [NUMBER]" where [NUMBER] is the actual count.
+5. Ensure all headings use the exact emoji and text format specified above

tasks/notion/standard/japan_travel_planner/daily_itinerary_overview/meta.json

@@ -0,0 +1,25 @@
+{
+  "task_id": "daily_itinerary_overview",
+  "task_name": "Daily Itinerary Overview",
+  "category_id": "japan_travel_planner",
+  "category_name": "Japan Travel Planner",
+  "description": "Create a comprehensive daily itinerary overview page to organize Japan travel plans with structured day-by-day activities.",
+  "author": "Xiangyan Liu",
+  "created_at": "2025-07-27",
+  "difficulty": "L3",
+  "tags": [
+    "database manipulation",
+    "data aggregation",
+    "report generation",
+    "visual formatting",
+    "status tracking"
+  ],
+  "mcp": [
+    "notion"
+  ],
+  "meta_data": {
+    "stateType": "url",
+    "stateContent": null,
+    "stateUrl": "https://painted-tennis-ebc.notion.site/Japan-Travel-Planner-23181626b6d781c4b6bedb12786b5abe"
+  }
+}