zvirb

---
name: Google Sheets Append Row
description: Atomic node skill to append a row in Google Sheets using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the append fails.

# Google Sheets Append Row

This skill allows the agent to append values to a range in a Google Sheet using the native CLI.

## Cognitive Directives
WHEN [New data rows need to be appended to a Google Sheet]
THEN [Execute the native terminal command `gog sheets append <spreadsheetId> <range> --values-json '[["..."]]'`]

## Schema Example
```json
{
  "command": "gog sheets append sheet_id_123 \"Tab1!A:C\" --values-json '[[\"Val1\", \"Val2\", \"Val3\"]]' --json"
}
```

## Expected Output
A JSON object confirming the appended rows.

---
name: executive-assistant-time-blocking
description: Workflow-driven skill that autonomously acts as an executive assistant to block out calendar time for incomplete tasks based on urgency and estimated duration.
os: all
requires:
  bins: [gog]
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill orchestrates multiple atomic nodes (tasks retrieval, cognitive assessment, calendar retrieval, gap analysis, and event creation) into a cohesive workflow, ensuring each step is validated before proceeding.
- **Standardized Work (Hyojun Sagyo):** This node represents the standardized standard operating procedure (SOP) for automated time-blocking and scheduling of user tasks.
- **Jidoka (自働化):** This workflow includes autonomous defect detection. It will check for calendar overlaps, verify event creation, and repeat scheduling steps if a slot is double-booked or an event fails to create.

# Executive Assistant Time Blocking

This skill directs the agent to evaluate current incomplete tasks from Google Tasks, estimate their duration and urgency, and sequentially schedule them into available gaps in Google Calendar.

## Cognitive Directives

WHEN [Requested to schedule tasks, time-block the backlog, or act as an executive assistant for schedule management]
THEN [
  Execute the following Jidoka-validated loop:

  1. **Task Collection:** Execute the native terminal command `gog tasks list @default --json` to retrieve all current incomplete tasks.
     - **Verification Step (Jidoka):** Check if the returned output is a valid JSON array of tasks. IF it fails or errors, report the error and STOP. IF empty, report that there are no tasks to schedule and STOP.

  2. **Cognitive Assessment (Triage):**
     - For each task, autonomously estimate the time required to complete it.
     - Assess the urgency of each task.
     - Judge when the task should be scheduled (e.g., today vs. another day soon).
     - **Verification Step (Jidoka):** Verify that *every* collected task has been assigned an estimated duration, an urgency score, and a target date. IF any task is missing these values, correct the assessment and retry before proceeding.

  3. **Schedule Retrieval:** 
     - For the target days identified, execute `gog calendar events primary --from "<start_date_iso>" --to "<end_date_iso>" --json` to retrieve currently booked events.
     - **Verification Step (Jidoka):** Verify the command returns a valid JSON array of events. IF it returns an error (e.g., rate limit or network error), wait 3 seconds and retry (max 3 times). IF it still fails, report the error and STOP.

  4. **Gap Analysis:**
     - Analyze the retrieved calendar events to identify gaps in the schedule.
     - **Constraint Check:** Ensure that gaps respect standard human needs (e.g., leave appropriate blocks of time for eating meals and sleeping).
     - **Verification Step (Jidoka):** Verify that the calculated gaps for a target day are large enough to fit the assigned tasks. IF there is insufficient time on the target day, reassign the overflow tasks to the next day, and repeat Step 3 (Schedule Retrieval) for the new target day.

  5. **Sequential Time Blocking (Jidoka Loop):**
     - Sequentially fit tasks into the schedule gaps based on their estimated duration and urgency.
     - For each fitted task, execute `gog calendar create primary --summary "[Task] <Task Title>" --from "<start_time_iso>" --to "<end_time_iso>" --json`.
     - **Verification Step:** After creation, execute `gog calendar events primary --from "<start_time_iso>" --to "<end_time_iso>" --json` again for that time slot to verify the event was correctly created and recalculate remaining gaps.

  6. **Overlap Audit & Remediation:**
     - Once all tasks have been assigned a block, perform a final audit using `gog calendar events` across all modified days.
     - Double-check that there are no overlaps or double-booked slots.
     - IF double-booking is detected: Delete or reschedule the conflicting task event (`gog calendar delete primary <eventId>`) and repeat the scheduling steps (Steps 3-5) until all tasks are booked without conflict.
]

## Expected Output
A comprehensive JSON or Markdown summary of the scheduled tasks, detailing the timeline, any constraints respected, and confirmation of overlap-free scheduling.

---
name: Event-Cancellation-Reconciler
description: Workflow-driven skill that autonomously detects cancelled events in emails and syncs the calendar state by deleting or updating orphaned calendar blocks.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is broken down into atomic steps: parsing the email intent, locating the stale event, and reconciling the state.
- **Standardized Work (Hyojun Sagyo):** This node represents the standardized workflow for state-syncing Google Calendar based on Gmail cancellation notices.
- **Jidoka (自働化):** Includes autonomous self-healing loops. If no event is found during the search phase, the agent stops and gracefully reports completion.

# Event Cancellation Reconciler

This skill orchestrates multiple tools to automatically remove or update calendar events when an email indicates a cancellation or reschedule, preventing stale state and double-booking.

## Cognitive Directives
WHEN [Requested to handle a cancelled event from an email OR when reading an email indicating a cancellation/reschedule]
THEN [
  Execute the following Jidoka-validated loop:
  1. Extract Event Details: Use the `LLM-Extract-JSON` or `LLM-Extract-Action-Items` skill against the email body to extract the `original_date`, `original_time`, and `target_entity` (event subject).
     - **Verification Step (Jidoka):** Verify the dates and subject are extracted. IF extraction fails, ask the user for the event details and STOP.
  2. Locate Orphaned Event: Execute the native terminal command `gog calendar search "<target_entity>" --json` or `gog calendar events primary --from "<original_date>T00:00:00Z" --to "<original_date>T23:59:59Z" --json` to locate the event ID.
     - **Verification Step (Jidoka):** Check if any events are returned. IF no matching event is found, reply "No conflicting calendar events found to clean up" and STOP.
  3. Reconcile State: Execute `gog calendar delete <event_id>` to clear the block, or optionally `gog calendar update <event_id> --summary "[CANCELLED] <original_title>"` to preserve a record.
     - **Verification Step (Jidoka):** Verify the native CLI returns a success response. IF it fails, log the failure and attempt to retry once before prompting the user.
  4. Notify: Reply to the user stating the cancellation has been processed and the calendar block is cleared.
]

## Expected Output
A confirmation message stating the calendar has been synced and the specific event has been deleted or marked as cancelled.

---
name: Google Drive Upload File
description: Atomic node skill to upload a file to Google Drive using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the upload fails.

# Google Drive Upload File

This skill allows the agent to upload a local file to Google Drive using the native CLI.

## Cognitive Directives
WHEN [A local file needs to be uploaded to Google Drive]
THEN [Execute the native terminal command `gog drive upload <localPath>`]

## Schema Example
```json
{
  "command": "gog drive upload /path/to/local/file.txt --json"
}
```

## Expected Output
A JSON object confirming the uploaded file and its Drive ID.

---
name: Google Drive Share File
description: Atomic node skill to share a file in Google Drive using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if sharing fails.

# Google Drive Share File

This skill allows the agent to share a file or folder in Google Drive using the native CLI.

## Cognitive Directives
WHEN [A file or folder needs to be shared with a user or made public]
THEN [Execute the native terminal command `gog drive share <fileId> --role reader --type user --email <email>`]

## Schema Example
```json
{
  "command": "gog drive share file_id_123 --role writer --type user --email [email protected] --json"
}
```

## Expected Output
A JSON object confirming the permission creation.

---
name: Google Drive Search Files
description: Atomic node skill to search for files in Google Drive using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the search fails.

# Google Drive Search Files

This skill allows the agent to search for files across Google Drive using the native CLI.

## Cognitive Directives
WHEN [A file or folder needs to be located in Google Drive]
THEN [Execute the native terminal command `gog drive search "query" --json`]

## Schema Example
```json
{
  "command": "gog drive search \"project proposal\" --json"
}
```

## Expected Output
A JSON array of file objects matching the search criteria.

---
name: Google Drive Download File
description: Atomic node skill to download a file from Google Drive using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the download fails.

# Google Drive Download File

This skill allows the agent to download a file from Google Drive using the native CLI.

## Cognitive Directives
WHEN [A file needs to be downloaded locally from Google Drive]
THEN [Execute the native terminal command `gog drive download <fileId> --out <localPath>`]

## Schema Example
```json
{
  "command": "gog drive download file_id_123 --out /tmp/document.pdf"
}
```

## Expected Output
Confirmation that the file was downloaded to the specified path.

---
name: Google Drive Delete File
description: Atomic node skill to delete a file in Google Drive using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the deletion fails.

# Google Drive Delete File

This skill allows the agent to move a file to trash in Google Drive using the native CLI.

## Cognitive Directives
WHEN [A file needs to be removed or moved to trash in Google Drive]
THEN [Execute the native terminal command `gog drive delete <fileId>`]

## Schema Example
```json
{
  "command": "gog drive delete file_id_123"
}
```

## Expected Output
Confirmation that the file was moved to the trash.

---
name: Google Docs Update Document
description: Atomic node skill to update a Google Doc using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the update fails.

# Google Docs Update Document

This skill allows the agent to write or insert text into an existing Google Document using the native CLI.

## Cognitive Directives
WHEN [Text needs to be added, written, or updated in a Google Doc]
THEN [Execute the native terminal command `gog docs write <docId> --text "..."` or `gog docs edit <docId> <find> <replace>`]

## Schema Example
```json
{
  "command": "gog docs edit doc_id_123 \"old text\" \"new text\""
}
```

## Expected Output
A JSON object or confirmation string indicating the update was successful.

---
name: Google Docs Read Document
description: Atomic node skill to read a Google Doc using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if reading fails.

# Google Docs Read Document

This skill allows the agent to read the plain text contents of a Google Document using the native CLI.

## Cognitive Directives
WHEN [The contents of a Google Doc need to be read]
THEN [Execute the native terminal command `gog docs cat <docId>`]

## Schema Example
```json
{
  "command": "gog docs cat doc_id_123"
}
```

## Expected Output
The plain text content of the Google Doc.

---
name: Google Docs Create Document
description: Atomic node skill to create a Google Doc using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the creation fails.

# Google Docs Create Document

This skill allows the agent to create a new Google Document using the native CLI.

## Cognitive Directives
WHEN [A new Google Doc needs to be created]
THEN [Execute the native terminal command `gog docs create <title> --json`]

## Schema Example
```json
{
  "command": "gog docs create \"My New Document\" --json"
}
```

## Expected Output
A JSON object with the new document ID and details.

---
name: Google Contacts Search
description: Atomic node skill to search google contacts. Loops internally until successful.
os: all
requires:
  bins:
    - gog
  env:
    - COMPOSIO_API_KEY
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It will stop immediately and report if it cannot achieve the expected outcome.



# Google Contacts Search

## Role
You are a precise tool orchestration node. Your only responsibility is to search google contacts.

## Input
A JSON object containing the required parameters for the execution.

## Expected Output
A JSON array representing the result of the operation.

---
name: Google Contacts Create
description: Atomic node skill to create a new google contact. Loops internally until successful.
os: all
requires:
  bins:
    - gog
  env:
    - COMPOSIO_API_KEY
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It will stop immediately and report if it cannot achieve the expected outcome.



# Google Contacts Create

## Role
You are a precise tool orchestration node. Your only responsibility is to create a new google contact.

## Input
A JSON object containing the required parameters for the execution.

## Expected Output
A JSON object representing the result of the operation.

---
name: Google Calendar Update Event
description: Atomic node skill to update a Google Calendar event using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the update fails.

# Google Calendar Update Event

This skill allows the agent to update an existing event in Google Calendar using the native CLI.

## Cognitive Directives
WHEN [An existing event needs to be modified or rescheduled]
THEN [Execute the native terminal command `gog calendar update <calendarId> <eventId> --summary "..." --from "..." --to "..."`]

## Schema Example
```json
{
  "command": "gog calendar update primary event_id_123 --summary \"Updated Sync Meeting\" --json"
}
```

## Expected Output
A JSON object confirming the updated event details.

---
name: Google Calendar Find Event
description: Atomic node skill to search for events in Google Calendar using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the search fails.

# Google Calendar Find Event

This skill allows the agent to search for events in Google Calendar within a specific time range using the native CLI.

## Cognitive Directives
WHEN [Requested to find events or check schedule for a specific period]
THEN [Execute the `gog` tool with the `args` parameter]

## Schema Example
```json
{
  "args": "calendar events primary --from \"2026-04-26T00:00:00Z\" --to \"2026-04-26T23:59:59Z\" --json"
}
```

## Expected Output
A JSON array of event objects matching the criteria.

---
name: Google Calendar Delete Event
description: Atomic node skill to delete a Google Calendar event using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the deletion fails.

# Google Calendar Delete Event

This skill allows the agent to delete an event from Google Calendar using the native CLI.

## Cognitive Directives
WHEN [An event needs to be removed or deleted from the calendar]
THEN [Execute the native terminal command `gog calendar delete <calendarId> <eventId>`]

## Schema Example
```json
{
  "command": "gog calendar delete primary event_id_123"
}
```

## Expected Output
Confirmation that the event was deleted.

---
name: Google Calendar Create Event
description: Atomic node skill to create a Google Calendar event using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the creation fails.

# Google Calendar Create Event

This skill allows the agent to create a new event in Google Calendar using the native CLI.

## Cognitive Directives
WHEN [A new event needs to be scheduled or created in the calendar]
THEN [Execute the `gog` tool with the `args` parameter]

## Schema Example
```json
{
  "args": "calendar create primary --summary \"New Sync Meeting\" --from \"2026-04-26T10:00:00Z\" --to \"2026-04-26T11:00:00Z\" --json"
}
```

## Expected Output
A JSON object confirming the created event details.

---
name: Gmail Send Email
description: Atomic node skill to send an email via Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if sending fails.

# Gmail Send Email

This skill allows the agent to send an email using the native CLI.

## Cognitive Directives
WHEN [An email needs to be sent to one or more recipients]
THEN [Execute the native terminal command `gog gmail send --to "..." --subject "..." --body "..."`]

## Schema Example
```json
{
  "command": "gog gmail send --to \"[email protected]\" --subject \"Invoice\" --body \"Please find the invoice attached.\" --json"
}
```

## Expected Output
Confirmation that the email was sent successfully.

---
name: Gmail Search Emails
description: Atomic node skill to search for emails in Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the search fails.

# Gmail Search Emails

This skill allows the agent to search for emails in Gmail using specific queries with the native CLI.

## Cognitive Directives
WHEN [Requested to search for an email or find specific communications]
THEN [Invoke the `gog` tool with the argument `gmail search "query" --json`]

## Schema Example
```json
{
  "args": "gmail search \"from:[email protected] subject:invoice\" --json"
}
```

## Expected Output
A JSON array containing email headers (id, threadId, snippet) or a "no results found" message.

---
name: Gmail Retrieve Email
description: Atomic node skill to read a specific email via Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if retrieval fails.

# Gmail Retrieve Email

This skill allows the agent to retrieve the full contents of a specific email using the native CLI.

## Cognitive Directives
WHEN [The contents of a specific email need to be read]
THEN [Execute the native terminal command `gog gmail messages get <messageId> --json`]

## Schema Example
```json
{
  "command": "gog gmail messages get msg_id_123 --json"
}
```

## Expected Output
A JSON object containing the email headers, body, and metadata.

---
name: Gmail Modify Labels
description: Atomic node skill to modify email labels in Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if the modification fails.

# Gmail Modify Labels

This skill allows the agent to add or remove labels from an email or thread using the native CLI.

## Cognitive Directives
WHEN [Labels on an email need to be changed, added, or removed]
THEN [
  Execute the following Jidoka-validated loop:
  1. **Execute Node:** Execute the native terminal command `gog gmail messages modify <messageId> ...` or equivalent label command.
  2. **Verification Step (Jidoka):** Verify the command returns a successful confirmation. IF it fails or returns an error message, wait 3 seconds and retry (max 3 times). IF it still fails, report the error to the user and STOP.
]

## Schema Example
```json
{
  "command": "gog gmail messages modify msg_id_123 --add-label INBOX --remove-label UNREAD --json"
}
```

## Expected Output
Confirmation that the labels were updated.

---
name: Gmail Draft Email
description: Atomic node skill to draft an email via Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if drafting fails.

# Gmail Draft Email

This skill allows the agent to create an email draft using the native CLI.

## Cognitive Directives
WHEN [An email needs to be drafted but not sent]
THEN [
  Execute the following Jidoka-validated loop:
  1. **Execute Node:** Execute the native terminal command `gog gmail drafts create --to "..." --subject "..." --body "..." --json`.
  2. **Verification Step (Jidoka):** Verify the command returns a valid JSON confirmation. IF it fails or returns an error message, wait 3 seconds and retry (max 3 times). IF it still fails, report the error to the user and STOP.
]

## Schema Example
```json
{
  "command": "gog gmail drafts create --to \"[email protected]\" --subject \"Invoice\" --body \"Please review the attached invoice.\" --json"
}
```

## Expected Output
Confirmation that the draft was created.

---
name: Gmail Delete Email
description: Atomic node skill to delete an email via Gmail using the gog CLI.
os: all
requires:
  bins:
    - gog
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It relies on the CLI's self-healing loop and will report errors if deletion fails.

# Gmail Delete Email

This skill allows the agent to move an email to the trash using the native CLI.

## Cognitive Directives
WHEN [An email needs to be deleted or moved to trash]
THEN [
  Execute the following Jidoka-validated loop:
  1. **Execute Node:** Execute the native terminal command `gog gmail trash <messageId>`.
  2. **Verification Step (Jidoka):** Check if the command returns a successful confirmation. IF it fails or returns an error, wait 3 seconds and retry (max 3 times). IF it still fails, report the error to the user and STOP.
]

## Schema Example
```json
{
  "command": "gog gmail trash msg_id_123"
}
```

## Expected Output
Confirmation that the email was moved to the trash.

---
name: flow-state-monitoring
description: Workflow-driven skill that infers deep focus and autonomously mutes interruptions.
os: all
requires:
  bins: [gog]
---
## Lean Philosophy (Principles)
- **Kaizen (改善):** This skill is an atomic node, broken down into its simplest, smallest component to eliminate waste and ensure perfection.
- **Standardized Work (Hyojun Sagyo):** This node represents the most efficient, standardized path for this specific task before automation.
- **Jidoka (自働化):** This node includes autonomous defect detection. It will stop immediately and report if it cannot achieve the expected outcome.

# Flow State Monitoring

This skill orchestrates a workflow to analyze focus telemetry and autonomously update your status in Google Workspace to protect your flow state.

## Cognitive Directives
WHEN [telemetry from local sensors indicates deep focus] 
THEN [
  Execute the following Jidoka-validated loop:
  1. Execute `llm_classify_intent` (Sub-Agent) to classify the activity.
     - **Verification Step (Jidoka):** Verify the sub-agent returns a valid classification (e.g., "Deep Work"). IF it hallucinates text, retry classification.
  2. IF classified as "Deep Work", Execute the native terminal command `gog calendar create primary --summary "Busy - In Flow"` to block interruptions.
     - **Verification Step (Jidoka):** Check if the calendar event creation returns a successful JSON response. IF it fails, wait 3 seconds and retry (max 3 times). IF it still fails, report the error and STOP.
]

## Expected Output
A JSON confirmation of the calendar status update.