agentleFS
afain12afain12/coo-twin/.claude/skills/end-day/SKILL.md

end-day

Skill0 starsChanged 6 months agoMITView on GitHub

End-of-day retro: compares the morning plan against what actually happened. Pulls current state from Calendar, Notion, Obsidian, and Google Tasks. Asks about unplanned work. Logs planned vs actual, carry-forwards, and observations. Updates state/priorities.yaml for tomorrow's /start-day.

  • Sends data out

2 other projects use a version of this.

Adopted by

Most recently taken up by

  • Other versions2 projects use a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 2

    1. braincandy-parallel/tamarindos-workflow-kit★ 0same name
    2. coder013/claude-skills★ 0same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

  • In this repository8 other files it gives its agents.

The file

Show its rules and text

We split this skill into the rules it gives an agent

33 rules. About 0 are common, 20 are distinctive, and 13 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈20

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 13

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read today's log file at ${LOGS_DIR}/{TODAY}.md.

    line 56
  2. Distinctive:

    If no morning log exists: warn "No morning briefing found for today.

    line 64
  3. Distinctive:

    Use Glob and file modification times to find notes created or modified today:

    line 165
  4. Distinctive:

    Check each vault folder for any files modified today.

    line 173
  5. Distinctive:

    Not Started: No change detected

    line 196
  6. Distinctive:

    Use AskUserQuestion to confirm the status of each Top 3 item:

    line 199
  7. Very specific:

    Read today's daily note at ${VAULT}/daily/{TODAY}.md and extract every checkbox line:

    line 216
  8. Very specific:

    Use a regex like <!--\s*(gtask|notion):([A-Za-z0-9_\-]+)\s*--> to extract.

    line 228
  9. Very specific:

    If a Google Tasks title match is found, look up the task ID by searching the morning's gws tasks tasks list output.

    line 238
  10. Distinctive:

    If a Notion title match is found via the morning's Master Tasks query, queue the Status=Done PATCH in 8e.

    line 240
  11. Distinctive:

    If B: ask which items to add, remove, or modify.

    line 398
  12. Very specific:

    Read ${VAULT}/daily/{TODAY}.md.

    line 420
  13. Distinctive:

    Use the Edit tool to replace the placeholder content in the existing daily note.

    line 436
  14. Distinctive:

    Important: never edit mid-file while the user may be appending to a Braindump section.

    line 439
  15. Very specific:

    Write carry-forward items to ${STATE}/priorities.yaml:

    line 477
  16. Distinctive:

    Completed carry-forwards: remove from the list

    line 496
  17. Distinctive:

    Items the user explicitly drops: remove from the list

    line 497
  18. Distinctive:

    Items carried 5+ days: add a note suggesting archival or delegation

    line 498
  19. Very specific:

    When /end-day builds carry-forwards, route items by signal:

    line 527
  20. Very specific:

    When awaiting_until passes without resolution, /start-day's "Awaiting Others" section flags the item with "deadline passed — re-engage".

    line 534
  21. Distinctive:

    If any Top 3 items were completed but their Notion status is still "In progress", offer to update them to "Done":

    line 539
  22. Distinctive:

    Only offer this, don't auto-execute.

    line 551
  23. Distinctive:

    Use the same PATCH /v1/pages/{page_id} call as Step 8d, with the page_id from the matched Notion source.

    line 567
  24. Distinctive:

    Failure handling: If a single sync write fails (404, 401, 5xx), report which item failed, continue with the remaining writes.

    line 572
  25. Very specific:

    Park to back-burner: Update the page title to prepend [BACK-BURNER], AND add an entry to the back_burner section of priorities.yaml.

    line 583
  26. Very specific:

    Keep as-is, snooze 5 days: Write a dormant_snooze entry to priorities.yaml with until: <today + 5d>.

    line 585
  27. Distinctive:

    All four operations follow the same trust-gate batching as 8e.

    line 588
  28. Very specific:

    Read mobile_briefing_page_id from ${CONFIG}.

    line 596
  29. Very specific:

    Read the just-updated ${VAULT}/daily/{TODAY}.md.

    line 597
  30. Very specific:

    If the Notion call fails → append a one-line ### Mobile Mirror entry to ${LOGS_DIR}/{TODAY}.md noting the failure reason.

    line 608
  31. Distinctive:

    If the Notion MCP is not loaded in the current session: skip silently.

    line 612
  32. Distinctive:

    No morning log: Run retro based on current state alone.

    line 666
  33. Distinctive:

    Obsidian daily note doesn't exist: Create a minimal one with just the EOD section.

    line 670

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

/end-day — Day Close Retro

You are acting as the user's Chief of Staff. Your job is to close the loop on today: compare the morning plan against reality, capture what drifted and why, and set up tomorrow by carrying forward unfinished work.

Read-first, write-on-approval. Show the retro summary before writing anything.

Constants

REPO_DIR = <your repo root>
CONFIG   = "${REPO_DIR}/config/sources.yaml"
LOGS_DIR = "${REPO_DIR}/logs"
VAULT    = "${REPO_DIR}/vault"
STATE    = "${REPO_DIR}/state"
TODAY    = <current date in YYYY-MM-DD format>
RUN_ID   = "ed-${TODAY//-/}-$(date +%H%M)"

Step 0: Mode Check (GOVERNED)

MODE=$(scripts/check_mode.sh) || {
  echo "Agent is locked. /end-day refuses to run."
  exit 0
}
  • locked → refuse.
  • observe → set SKIP_WRITES=1; build retro, display, do NOT update priorities.yaml or push completions.
  • draft (default) → standard trust gate.
  • approved → /end-day's writes (state file edits, sync pushes, dead-task resolutions) check action_id prefixes per state/coo_mode.yaml.

Capture RUN_START_MS for telemetry at Step 10.

Step 1: Load Morning Plan

Read today's log file at ${LOGS_DIR}/{TODAY}.md.

Extract from the morning briefing:

  • Top 3 Outcomes — the scored priorities from this morning
  • Calendar events — what was scheduled
  • Actionable items by stream — the full checklist
  • Sources available/skipped — what data was available this morning

If no morning log exists: warn "No morning briefing found for today. Running /end-day without a morning plan — I'll still capture what happened today." Continue with Steps 2-4 to build the retro from current state alone.

Also read ${STATE}/priorities.yaml for any carry-forward items from yesterday.

Step 2: Pull Current State

2a: Google Calendar — What Actually Happened

gws calendar +agenda --today --format json

Compare against the morning calendar:

  • Events that were added after the morning briefing
  • Events that were cancelled or moved
  • Events that happened as planned

If gws fails: Skip. Note in retro.

2b: Notion — Changes Since Morning

Query all three databases for pages edited today.

Master Tasks:

curl -s -X POST "https://api.notion.com/v1/data_sources/{master_tasks_ds_id}/query" \
  -H "Authorization: Bearer $NOTION_API_TOKEN" \
  -H "Notion-Version: 2025-09-03" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{
    "filter": {
      "timestamp": "last_edited_time",
      "last_edited_time": {"on_or_after": "<TODAY>T00:00:00Z"}
    },
    "page_size": 50
  }'

Categorize each page:

  • Completed today: Status changed to "Done"
  • Moved to In Progress: Status is now "In progress" and wasn't this morning
  • New items created: created_time is today
  • Edited: Any other page modified today

Provider CRM:

curl -s -X POST "https://api.notion.com/v1/data_sources/{provider_crm_ds_id}/query" \
  -H "Authorization: Bearer $NOTION_API_TOKEN" \
  -H "Notion-Version: 2025-09-03" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{
    "filter": {
      "timestamp": "last_edited_time",
      "last_edited_time": {"on_or_after": "<TODAY>T00:00:00Z"}
    },
    "page_size": 50
  }'

Activity Log:

curl -s -X POST "https://api.notion.com/v1/data_sources/{activity_log_ds_id}/query" \
  -H "Authorization: Bearer $NOTION_API_TOKEN" \
  -H "Notion-Version: 2025-09-03" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{
    "filter": {
      "property": "Date",
      "date": {"equals": "<TODAY>"}
    },
    "page_size": 20
  }'

If Notion fails: Skip. Note in retro.

2c: Google Tasks — Completed and New

gws tasks tasks list --params '{"tasklist":"<DEFAULT_TASKLIST_ID>","showCompleted":true,"completedMin":"<TODAY>T00:00:00Z"}'

Also fetch current incomplete tasks to compare against morning state:

gws tasks tasks list --params '{"tasklist":"<DEFAULT_TASKLIST_ID>"}'

Identify:

  • Tasks completed today
  • New tasks added today
  • Tasks still incomplete that were in the morning's list

If gws fails: Skip. Note in retro.

2d: Obsidian — New Notes Today

Use Glob and file modification times to find notes created or modified today:

${VAULT}/notes/*.md    — new permanent notes
${VAULT}/meetings/*.md — meeting notes captured today
${VAULT}/inbox/*.md    — new inbox captures

Check each vault folder for any files modified today.

Step 3: Ask About Unplanned Work

Use AskUserQuestion:

"Anything major happened today that isn't in your calendar or Notion?" "(e.g., fires, long calls, unexpected work, ad-hoc meetings)"

Options:

  • Nothing major — Proceed with tool-tracked data only
  • Yes, let me add context — User types unplanned work

Store the response as unplanned_work for the retro.

Step 4: Compare Planned vs Actual

4a: Top 3 Outcomes Assessment

For each of the morning's Top 3 Outcomes, determine status:

  • Completed: Found in completed Notion tasks or Google Tasks
  • In Progress: Status is "In progress" in Notion, or partially done
  • Not Started: No change detected
  • Blocked: Status is "Waiting" or user mentioned a blocker

Use AskUserQuestion to confirm the status of each Top 3 item:

"How did your Top 3 go today?"

Display each item and ask the user to confirm or correct:

1. {item 1} — I see {detected status}. Correct?
2. {item 2} — I see {detected status}. Correct?
3. {item 3} — I see {detected status}. Correct?

Options:

  • Looks right — Accept auto-detected statuses
  • Let me correct — User provides corrections

4b: Stream Checklist Reconciliation + Sync Loop

Read today's daily note at ${VAULT}/daily/{TODAY}.md and extract every checkbox line:

  • - [x] → user marked it complete during the day
  • - [ ] → still open

Build a checkbox_completions list of every [x] item. For each completed item, parse the line for an embedded source-ID HTML comment written by /start-day (Step 9, daily-note template):

  • <!-- gtask:<ID> --> → Google Tasks task ID. Queue an exact-ID complete in 8e.
  • <!-- notion:<ID> --> → Notion page ID. Queue an exact-ID Status=Done flip in 8e.

Use a regex like <!--\s*(gtask|notion):([A-Za-z0-9_\-]+)\s*--> to extract. Exact-ID matching is durable; do NOT fall back to fuzzy title matching when an ID is present.

For checked items with no embedded ID (legacy daily notes or manual additions):

  1. Best-effort title match against this morning's actionable items in the briefing (${LOGS_DIR}/{TODAY}.md). Source tags like (Notion), (Tasks), (CRM) indicate which system to query.
  2. If a Google Tasks title match is found, look up the task ID by searching the morning's gws tasks tasks list output. Queue completion in 8e.
  3. If a Notion title match is found via the morning's Master Tasks query, queue the Status=Done PATCH in 8e.
  4. No match found → record as manual_completions (logged only, no write).

Conversely, items completed in Notion/Tasks but NOT checked in the daily note remain a reconciliation gap — surface them in the retro under "Sync gaps" so the daily note matches reality.

Bidirectional Notion → Google Tasks sync:

For every Notion Master Task whose Status changed to "Done" today (detected in Step 2b), read its Last Activity rich_text property. If it contains gtask:<ID>, queue a Google Tasks completion in Step 8e for that task ID. This closes the reverse loop: when a Notion subtask flips to Done in the Notion UI, the mirrored Google Task auto-completes on /end-day.

The Last Activity back-pointer is written by /capture-meeting Step 6a-3 when the Google Tasks mirror is created.

4c: Dead-Task EOL Scan

Scan all Notion Master Tasks where Status = "In progress" and last_edited_time is more than 5 days old. For each, build a dead_tasks list:

  • Title
  • page_id
  • Days since last edit
  • Workspace (stream)

These are zombie tasks — listed as active but with no movement. They must be explicitly resolved on each /end-day, not silently re-surfaced. Show them in the retro (Step 6) and require an action via the trust gate (Step 7).

4d: Calendar Drift

Compare morning calendar vs actual:

  • List events that were added, removed, or moved
  • Note any meetings that ran over their scheduled time (if user mentioned)

Step 5: Build Carry-Forward List

Items that carry forward to tomorrow:

  1. Unfinished Top 3 items — auto-carry unless user explicitly drops them
  2. Items from morning checklist not completed — only high-priority ones
  3. New items created today that need follow-up — from Notion/Tasks changes
  4. Yesterday's carry-forwards that weren't addressed — increment days_carried

For each carry-forward candidate, the user should confirm at the trust gate (Step 6). Items carried for 3+ days get a special flag.

Step 6: Compose and Display Retro

Output the retro to the terminal:

# End of Day — {TODAY} ({day of week})

## Top 3 Outcomes: How'd It Go?
1. {item} — {status} {context}
2. {item} — {status} {context}
3. {item} — {status} {context}

**Score: {completed}/{total}**

## What Got Done Today

### Completed
- {completed items from Notion, Tasks, and Calendar — grouped by stream}

### New Items Created
- {new Notion pages, new Tasks, new Obsidian notes}

### Provider / CRM Activity
- {CRM updates, activity log entries}

## What Drifted

### Calendar Changes
- {events added/removed/moved since morning}

### Unplanned Work
- {user-reported unplanned items, or "None reported"}

### Items Not Touched
- {items from morning plan that had no activity}

## Sync Loop (Obsidian ↔ Tasks/Notion)

### Checkboxes ticked off in today's daily note
- {N items} — {list with their source: Notion / Tasks / Manual}

### Sync gaps (completed in source but not checked in daily note)
- {item completed in Notion/Tasks but `[ ]` in daily note} — verify before close

### Pending writes (will execute on approval at trust gate)
- Mark {N} Google Tasks as completed (one curl/gws call each)
- Set {N} Notion Master Tasks to "Done" (PATCH /v1/pages/{id})
- Manual completions logged only: {N}

## Dead Tasks (In Progress > 5 days, no edits)

For each dead task, require explicit action at the trust gate:
- {Title} — {N} days dormant [{stream}]

## Carry Forward to Tomorrow

{Each item with days_carried count}
- {item} — carried {N} day(s) [{stream}]
- {item} — NEW carry-forward [{stream}]

{Items carried 3+ days get a warning:}
> Carried 3+ days: {item}. Still a priority, or should it be dropped/delegated?

## Real Movement off Top 3 (OBSERVED — first-class metric)

Ask explicitly about Top 3 movement even when system data shows 0/3. In-person
work bypasses Notion/Tasks; a 0/3 score on an all-meetings day is wrong.

- Top 3 system-tracked completions: {N}/3
- Real movement (self-report): {M}/3
- If divergence > 0: log to telemetry as `real_vs_tracked_delta` for trend.

## DLQ Status (OBSERVED — surface hidden queues)

Read `${STATE}/gtask-retry-queue.yaml` if present. Report:

- **Pending retries:** {N} items, oldest {M} days
- {For each item carrying >=3 days: show title + attempts + last_status}

If N > 0 AND the oldest is >=3 days, surface this as a system flag — the API
is persistently flaky for that ID, not just a transient burst.

## Today's Observations

{Single-day observations only — cross-day patterns are for /weekly-review}
- {e.g., "4 of 5 meetings were stream A but top outcomes were stream B tasks"}
- {e.g., "3 new tasks created today, only 1 completed — inflow exceeding output"}
- {e.g., "No Obsidian notes created — consider capturing one key insight"}

## Skipped Sources
{List any sources that were unavailable}

Step 7: Trust Gate

Use AskUserQuestion:

"What would you like to do with this retro?"

Options:

  • A) Save everything + sync loop — Update daily note, log, carry-forwards, AND push all queued sync writes (close Google Tasks, flip Notion to Done) for items checked off in the daily note. Includes resolving dead tasks per Step 7b.
  • B) Edit carry-forwards/syncs first — Add/remove/modify carry-forward items, opt out of any queued sync writes, or override dead-task resolutions before saving.
  • C) Just the summary — Don't write anything, review only.

If B: ask which items to add, remove, or modify. Then save.

Step 7b: Dead-task resolution (only if Step 4c found any)

For each item in dead_tasks, use AskUserQuestion to force a decision:

"{title} — In Progress for {N} days with no edits. What's the call?"

Options (per task):

  • Mark Done — flip Notion status to Done (will execute in 8f)
  • Set hard due date — prompt for a date, update Notion Due (executes in 8f)
  • Park to back-burner — prepend [BACK-BURNER] and rotate to priorities.yaml back-burner section
  • Keep as-is, ignore for 5 more days — log a snooze; don't surface again until 10 days dormant

Record each decision; do not act until trust gate (Step 7) is approved.

Step 8: Execute Approved Actions

8a: Update Obsidian Daily Note

Read ${VAULT}/daily/{TODAY}.md. Find the "End of Day Review" section (it's part of the /start-day template) and fill it in:

## End of Day Review

**Completed:**
- [x] {each completed item}

**Carries forward to tomorrow:**
- [ ] {each carry-forward item with context}

**Notes / Decisions made today:**
- {observations and decisions from the retro}

Use the Edit tool to replace the placeholder content in the existing daily note. If the daily note doesn't exist, create it with just the EOD content.

Important: never edit mid-file while the user may be appending to a Braindump section. Only fill the dedicated EOD Review placeholders; append new content at the bottom or write to logs/priorities instead.

8b: Append to Log File

Append the retro to ${LOGS_DIR}/{TODAY}.md:


---

## End of Day ({current time})

### Top 3 Results
{status of each Top 3 item}

### Completed Today
{list of completed items with sources}

### New Items Created
{list}

### Unplanned Work
{user input or "None"}

### Calendar Drift
{changes}

### Carry Forward
{list with days_carried}

### Observations
{observations}

8c: Update State File

Write carry-forward items to ${STATE}/priorities.yaml:

carry_forward:
  - title: "Task description"
    source: notion
    source_id: "page-id-if-available"
    stream: stream-a
    first_carried: "YYYY-MM-DD"
    days_carried: 1
    original_due: "YYYY-MM-DD"
    notes: "context from today"

last_updated: "YYYY-MM-DD"

Rules for updating priorities.yaml:

  • New carry-forwards: first_carried = today, days_carried = 1
  • Existing carry-forwards still unfinished: increment days_carried by 1
  • Completed carry-forwards: remove from the list
  • Items the user explicitly drops: remove from the list
  • Items carried 5+ days: add a note suggesting archival or delegation

In addition to carry_forward, priorities.yaml has three more top-level sections:

awaiting:
  - title: "Item — contact's response"
    blocked_on: "<contact>"        # who/what we're waiting on
    nudged_at: "YYYY-MM-DD"        # last time we contacted them
    waiting_since: "YYYY-MM-DD"
    awaiting_until: "YYYY-MM-DD"   # if absent, no auto-rotation; if past, /start-day flags as expired
    stream: stream-a
    source: tasks
    source_id: null
    notes: "Email sent. Last update: ..."

dormant_snooze:
  # Used by Step 8f's "Keep as-is, snooze 5 days" path. /end-day Step 4c
  # skips dead-task surfacing for any page_id with `until` still in the future.
  - page_id: "<notion_page_id>"
    title: "Item title"
    until: "YYYY-MM-DD"

back_burner:
  # Items moved here by Step 8f or by manual user direction. Renamed inline in
  # Notion with [BACK-BURNER] prefix; rotated out of carry_forward.

When /end-day builds carry-forwards, route items by signal:

  • Notes/title contain "await", "awaiting", "blocked on", "from him/her" + a person name → awaiting: bucket
  • User explicitly snoozed dead task → dormant_snooze:
  • User explicitly parked → back_burner:
  • Everything else still active → carry_forward:

When awaiting_until passes without resolution, /start-day's "Awaiting Others" section flags the item with "deadline passed — re-engage".

8d: Check for Notion Status Updates (Optional)

If any Top 3 items were completed but their Notion status is still "In progress", offer to update them to "Done":

curl -s -X PATCH "https://api.notion.com/v1/pages/{page_id}" \
  -H "Authorization: Bearer $NOTION_API_TOKEN" \
  -H "Notion-Version: 2025-09-03" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{"properties": {"Status": {"status": {"name": "Done"}}}}'

Only offer this, don't auto-execute.

8e: Sync Completed Checkboxes Back to Source

For every item in checkbox_completions from Step 4b that traces back to a source, push the completion. Approved as a batch via Option A in Step 7.

Google Tasks completions:

gws tasks tasks patch \
  --params '{"tasklist":"<DEFAULT_TASKLIST_ID>","task":"<TASK_ID>"}' \
  --json '{"status":"completed"}' \
  --format json

Notion task completions: Use the same PATCH /v1/pages/{page_id} call as Step 8d, with the page_id from the matched Notion source. One call per task; no batching.

Manual completions (no source match): log only — no external write.

Failure handling: If a single sync write fails (404, 401, 5xx), report which item failed, continue with the remaining writes. Do not retry. The next morning's /start-day will resurface any item that didn't sync.

8f: Execute Dead-Task Resolutions

For each decision recorded in Step 7b:

  • Mark Done: PATCH the Notion page Status → "Done" (same call shape as 8d).
  • Set hard due date: PATCH the Notion page with {"properties":{"Due":{"date":{"start":"YYYY-MM-DD"}}}}.
  • Park to back-burner: Update the page title to prepend [BACK-BURNER], AND add an entry to the back_burner section of priorities.yaml.
  • Keep as-is, snooze 5 days: Write a dormant_snooze entry to priorities.yaml with until: <today + 5d>.

All four operations follow the same trust-gate batching as 8e.

8g: Optional — Mirror daily note to a Notion page

By this point the daily note's "End of Day Review" section is filled in (8a) and any source-system writes (8d/8e/8f) have landed. Push the final state to a Notion page so it's readable from your phone.

  1. Read mobile_briefing_page_id from ${CONFIG}. If unset, skip silently.
  2. Read the just-updated ${VAULT}/daily/{TODAY}.md.
  3. Strip the YAML frontmatter.
  4. Replace the page's content using the Notion MCP:
    mcp__claude_ai_Notion__notion-update-page
      page_id: <mobile_briefing_page_id>
      command: "replace_content"
      new_str: <stripped markdown body>
      properties: {}
      content_updates: []
  5. If the Notion call fails → append a one-line ### Mobile Mirror entry to ${LOGS_DIR}/{TODAY}.md noting the failure reason. Do not retry. Do not block.

If the Notion MCP is not loaded in the current session: skip silently.

Step 9: Summary

# Day Closed

**Top 3 Score:** {completed}/{total}
**Items completed today:** {count}
**Carry-forwards for tomorrow:** {count} ({N} new, {M} continued)
**Daily note updated:** {yes/no}
**Log saved:** {yes/no}
**Priorities state updated:** {yes/no}

{If any carry-forwards are 3+ days old:}
> Consider reviewing long-standing items during your next /weekly-review.

Good night.

Step 10: Emit Telemetry (OBSERVED)

DURATION_MS=$(( $(date +%s%3N 2>/dev/null || python -c "import time; print(int(time.time()*1000))") - RUN_START_MS ))

scripts/telemetry.sh end-day "${RUN_ID}" "${DURATION_MS}" "${STATUS}" "$(python -c "
import json
print(json.dumps({
    'mode': '${MODE}',
    'top3_tracked': ${TOP3_TRACKED_COUNT},          # what Notion/Tasks closed today
    'top3_real': ${TOP3_REAL_COUNT},                # self-reported real movement
    'real_vs_tracked_delta': ${TOP3_REAL_COUNT} - ${TOP3_TRACKED_COUNT},
    'completed_today': ${COMPLETED_COUNT},
    'new_items_today': ${NEW_ITEMS_COUNT},
    'unplanned_work_reported': ${UNPLANNED_BOOL},
    'carry_forward_new': ${CARRY_NEW},
    'carry_forward_continued': ${CARRY_CONTINUED},
    'carry_forward_3plus_days': ${CARRY_3PLUS},
    'dead_tasks_resolved': ${DEAD_RESOLVED_COUNT},
    'gtask_retry_queue_depth': ${DLQ_DEPTH},
    'gtask_retry_queue_oldest_days': ${DLQ_OLDEST_DAYS},
    'sync_pull_completions': ${PULL_COUNT},
    'sync_push_completions': ${PUSH_COUNT},
    'sync_push_failures': ${PUSH_FAIL_COUNT}
})
")"

STATUS is ok (retro built + writes succeeded), partial (>=1 source down or >=1 write failed), or failed (couldn't build retro).

Error Handling

  • scripts/check_mode.sh exits 1 (locked): Refuse. No telemetry.
  • No morning log: Run retro based on current state alone. Warn but don't fail.
  • Notion API failure: Report which databases were unreachable. Use whatever data is available from other sources. Note in retro. Telemetry status = partial.
  • gws CLI failure: Skip calendar/tasks comparison. Note in retro.
  • Obsidian daily note doesn't exist: Create a minimal one with just the EOD section.
  • State file corrupted: Regenerate priorities.yaml from today's retro data. Warn user that previous carry-forward history may be lost.
  • Never retry automatically. Report clearly and continue.
  • Never crash on a missing source. The retro runs with whatever is available.

Success Criterion

Running /end-day in draft mode produces a retro that:

  • Cites each Top 3 item with detected vs self-reported status
  • Reconciles daily-note checkboxes against source-system state in both directions
  • Lists dead tasks and forces an explicit resolution decision
  • Writes carry-forwards to priorities.yaml so tomorrow's /start-day sees them
  • Emits one telemetry row that captures both tracked and self-reported Top 3 movement.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.