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
- coder013/claude-skillstheir own version, first seen Nov 16, 2026
- braincandy-parallel/tamarindos-workflow-kittheir own version, first seen Sep 18, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- braincandy-parallel/tamarindos-workflow-kit★ 0same name
- 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.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- capture-meetingSkill
- notion-mapSkill
- notion-probeSkill
- notion-template-installSkill
- setupSkill
- start-daySkill
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
- Very specific: line 56
Read today's log file at ${LOGS_DIR}/{TODAY}.md.
- Distinctive: line 64
If no morning log exists: warn "No morning briefing found for today.
- Distinctive: line 165
Use Glob and file modification times to find notes created or modified today:
- Distinctive: line 173
Check each vault folder for any files modified today.
- Distinctive: line 196
Not Started: No change detected
- Distinctive: line 199
Use AskUserQuestion to confirm the status of each Top 3 item:
- Very specific: line 216
Read today's daily note at ${VAULT}/daily/{TODAY}.md and extract every checkbox line:
- Very specific: line 228
Use a regex like <!--\s*(gtask|notion):([A-Za-z0-9_\-]+)\s*--> to extract.
- Very specific: line 238
If a Google Tasks title match is found, look up the task ID by searching the morning's gws tasks tasks list output.
- Distinctive: line 240
If a Notion title match is found via the morning's Master Tasks query, queue the Status=Done PATCH in 8e.
- Distinctive: line 398
If B: ask which items to add, remove, or modify.
- Very specific: line 420
Read ${VAULT}/daily/{TODAY}.md.
- Distinctive: line 436
Use the Edit tool to replace the placeholder content in the existing daily note.
- Distinctive: line 439
Important: never edit mid-file while the user may be appending to a Braindump section.
- Very specific: line 477
Write carry-forward items to ${STATE}/priorities.yaml:
- Distinctive: line 496
Completed carry-forwards: remove from the list
- Distinctive: line 497
Items the user explicitly drops: remove from the list
- Distinctive: line 498
Items carried 5+ days: add a note suggesting archival or delegation
- Very specific: line 527
When /end-day builds carry-forwards, route items by signal:
- Very specific: line 534
When awaiting_until passes without resolution, /start-day's "Awaiting Others" section flags the item with "deadline passed — re-engage".
- Distinctive: line 539
If any Top 3 items were completed but their Notion status is still "In progress", offer to update them to "Done":
- Distinctive: line 551
Only offer this, don't auto-execute.
- Distinctive: line 567
Use the same PATCH /v1/pages/{page_id} call as Step 8d, with the page_id from the matched Notion source.
- Distinctive: line 572
Failure handling: If a single sync write fails (404, 401, 5xx), report which item failed, continue with the remaining writes.
- Very specific: line 583
Park to back-burner: Update the page title to prepend [BACK-BURNER], AND add an entry to the back_burner section of priorities.yaml.
- Very specific: line 585
Keep as-is, snooze 5 days: Write a dormant_snooze entry to priorities.yaml with until: <today + 5d>.
- Distinctive: line 588
All four operations follow the same trust-gate batching as 8e.
- Very specific: line 596
Read mobile_briefing_page_id from ${CONFIG}.
- Very specific: line 597
Read the just-updated ${VAULT}/daily/{TODAY}.md.
- Very specific: line 608
If the Notion call fails → append a one-line ### Mobile Mirror entry to ${LOGS_DIR}/{TODAY}.md noting the failure reason.
- Distinctive: line 612
If the Notion MCP is not loaded in the current session: skip silently.
- Distinctive: line 666
No morning log: Run retro based on current state alone.
- Distinctive: line 670
Obsidian daily note doesn't exist: Create a minimal one with just the EOD section.
≈ “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.
Files
/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→ setSKIP_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 perstate/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 jsonCompare 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_timeis 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 capturesCheck 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):
- 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. - If a Google Tasks title match is found, look up the task ID by searching
the morning's
gws tasks tasks listoutput. Queue completion in 8e. - If a Notion title match is found via the morning's Master Tasks query, queue the Status=Done PATCH in 8e.
- 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:
- Unfinished Top 3 items — auto-carry unless user explicitly drops them
- Items from morning checklist not completed — only high-priority ones
- New items created today that need follow-up — from Notion/Tasks changes
- 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_carriedby 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 jsonNotion 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 theback_burnersection ofpriorities.yaml. - Keep as-is, snooze 5 days: Write a
dormant_snoozeentry topriorities.yamlwithuntil: <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.
- Read
mobile_briefing_page_idfrom${CONFIG}. If unset, skip silently. - Read the just-updated
${VAULT}/daily/{TODAY}.md. - Strip the YAML frontmatter.
- 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: [] - If the Notion call fails → append a one-line
### Mobile Mirrorentry to${LOGS_DIR}/{TODAY}.mdnoting 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.yamlfrom 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.yamlso tomorrow's/start-daysees them - Emits one telemetry row that captures both tracked and self-reported Top 3 movement.
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
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.

