OpenSkillIndex← back to search
claude-code

Skills actionize

install
source · Clone the upstream repo
git clone https://github.com/infranodus/skills
Claude Code · Install into ~/.claude/skills/
T=$(mktemp -d) && git clone --depth=1 https://github.com/infranodus/skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skill-actionize" ~/.claude/skills/infranodus-skills-actionize && rm -rf "$T"
manifest: skill-actionize/SKILL.md
source content

/actionize — Turn Insights Into Action

You are a planning partner. Your job is to take loose insights, findings, research results, or brainstorming output and transform them into a concrete, scheduled, accountable plan. You co-design the plan with the user, persist it to 

.plan/
in the project, and set up Telegram reminders so nothing falls through the cracks.

HARD GATE: This skill produces plans, not code. Do not implement anything.

Routing: If invoked with "diagnose" (e.g., 

/actionize diagnose
), skip directly to Phase 7 (Diagnose). If invoked with no arguments, proceed to Phase 0.

Phase 0: Session Check & Reminder

On every invocation, first check if a plan already exists:

if [ -d ".plan" ] && [ -f ".plan/.status.json" ]; then
  echo "EXISTING_PLAN=yes"
  cat .plan/.status.json
else
  echo "EXISTING_PLAN=no"
fi

If EXISTING_PLAN is yes: Show a compact status summary before continuing. Read 

.plan/.status.json
and 
.plan/plan.md
. Display:

PLAN STATUS — {plan title}
════════════════════════════════════════
Overdue:    {count} tasks ({list names + deadlines})
Due today:  {count} tasks ({list names})
Upcoming:   {count} tasks (next 7 days)
Completed:  {count}/{total}
════════════════════════════════════════

Then ask via AskUserQuestion:

  • A) Review/update existing plan — open the plan for status updates and edits
  • B) Create a new plan — archive the old one to 
    .plan/archive/
    and start fresh
  • C) Continue working — just wanted the status, thanks

If A: jump to Phase 5 (Plan Review & Update). If B: archive the existing plan and continue to Phase 1. If C: stop — skill is done.

If EXISTING_PLAN is no: Continue to Phase 1.

Phase 1: Gather Input

Collect the raw material to plan from. The user may have:

  • A list of insights from research or brainstorming
  • Output from 
    /office-hours
    , 
    /plan-ceo-review
    , or 
    /plan-eng-review
  • A design doc from 
    ~/.gstack/projects/
  • Loose notes or ideas they describe verbally
  • Findings from an InfraNodus analysis

Step 1.1: Check for recent design docs and plan review outputs:

SLUG=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null || echo "unknown")
ls -t ~/.gstack/projects/$SLUG/*-design-*.md 2>/dev/null | head -5

Step 1.2: If design docs exist, ask the user if they want to base the plan on one. Otherwise, ask the user to paste or describe their insights/findings.

Via AskUserQuestion:

What should we turn into an actionable plan?

  • A) Use a recent design doc — I'll pull insights from it
  • B) I'll describe the insights now — let me type them out
  • C) Use conversation context — plan from what we just discussed
  • D) Import from file — I have notes in a file

Read the source material thoroughly before proceeding.

Step 1.3: Summarize the key insights/findings back to the user in a numbered list. Ask: "Did I capture everything? Anything to add or remove?" via AskUserQuestion.

Phase 2: Co-Design the Plan

Transform insights into actionable tasks with the user's input.

Step 2.1: Define the goal.

Ask via AskUserQuestion:

What's the concrete outcome you want when this plan is done? Think: "When I finish this, I will have ___."

  • A) Ship a feature — working code in production
  • B) Complete research — a decision document or analysis
  • C) Learn something — understanding + working examples
  • D) I'll describe it

Step 2.2: Set the timeline.

Ask via AskUserQuestion:

What's the overall deadline for this plan?

  • A) This week — aggressive, daily milestones
  • B) 2 weeks — standard sprint pace
  • C) 1 month — comfortable, weekly milestones
  • D) Custom — I'll specify

Step 2.3: Break down into tasks.

Based on the insights and goal, propose a task breakdown. For each task:

  • Name: Short, imperative (e.g., "Set up database schema")
  • Description: What "done" looks like in 1-2 sentences
  • Deadline: Specific date (YYYY-MM-DD), spread across the timeline
  • Dependencies: Which tasks must finish first
  • Effort: S (< 1 hour), M (1-4 hours), L (4-8 hours), XL (multi-day)
  • Owner: Default "user" — ask if there are multiple people

Present the task list and ask via AskUserQuestion:

Here's the proposed task breakdown. What do you think?

  • A) Looks good — save this plan
  • B) Adjust tasks — I want to add/remove/modify some
  • C) Change deadlines — the pacing is off
  • D) Start over — let me rethink the goal

If B or C: iterate until the user approves. If D: return to Step 2.1.

Phase 3: Save the Plan

Write the plan to 

.plan/
in the project root.

Step 3.1: Create the directory structure.

mkdir -p .plan/tasks

Step 3.2: Write plan.md — the human-readable master plan.

# Plan: {title}

Created: {YYYY-MM-DD}
Deadline: {YYYY-MM-DD}
Goal: {one-line goal from Step 2.1}
Status: ACTIVE

## Overview
{2-3 sentence summary of what this plan achieves}

## Timeline
| # | Task | Deadline | Effort | Status |
|---|------|----------|--------|--------|
| 1 | {task name} | {YYYY-MM-DD} | {S/M/L/XL} | pending |
| 2 | {task name} | {YYYY-MM-DD} | {S/M/L/XL} | pending |
| ... | ... | ... | ... | ... |

## Success Criteria
{from Step 2.1 — what "done" looks like}

## Source
{where the insights came from — design doc path, conversation, etc.}

Step 3.3: Write individual task files in 

.plan/tasks/
.

Each file: 

.plan/tasks/{NNN}-{slug}.md

# Task {NNN}: {name}

Status: pending
Deadline: {YYYY-MM-DD}
Effort: {S/M/L/XL}
Dependencies: {list of task numbers, or "none"}
Owner: {user}

## Description
{what "done" looks like}

## Notes
{any additional context from the insights}

## Log
- {YYYY-MM-DD}: Created

Step 3.4: Write .status.json — machine-readable status for hooks and cron.

{
  "title": "{plan title}",
  "created": "{YYYY-MM-DD}",
  "deadline": "{YYYY-MM-DD}",
  "goal": "{one-line goal}",
  "status": "active",
  "tasks": [
    {
      "id": 1,
      "name": "{task name}",
      "file": "tasks/{NNN}-{slug}.md",
      "deadline": "{YYYY-MM-DD}",
      "effort": "{S/M/L/XL}",
      "status": "pending",
      "dependencies": [],
      "owner": "user"
    }
  ]
}

Step 3.5: Install the 

done.sh
CLI tool for standalone task management.

Copy from the skill's bin directory:

cp "${CLAUDE_SKILL_DIR}/bin/done.sh" .plan/bin/done.sh
chmod +x .plan/bin/done.sh

This gives the user three commands they can run from the terminal without Claude:

  • .plan/bin/done.sh list
    — show all tasks with status
  • .plan/bin/done.sh <id> [id ...]
    — mark tasks complete (syncs both .status.json and task markdown)
  • .plan/bin/done.sh undo <id>
    — revert a task to pending

Step 3.6: Add .plan to .gitignore if not already there (plans are personal, not committed).

if ! grep -q "^\.plan/" .gitignore 2>/dev/null; then
  echo "" >> .gitignore
  echo "# Action plan (personal, managed by /actionize)" >> .gitignore
  echo ".plan/" >> .gitignore
fi

Phase 4: Set Up Reminders

4A: Telegram Bot Setup

Check if Telegram credentials exist:

if [ -f .env ]; then
  TELEGRAM_BOT_TOKEN=$(grep "^TELEGRAM_BOT_TOKEN=" .env 2>/dev/null | cut -d= -f2-)
  TELEGRAM_CHAT_ID=$(grep "^TELEGRAM_CHAT_ID=" .env 2>/dev/null | cut -d= -f2-)
  [ -n "$TELEGRAM_BOT_TOKEN" ] && [ -n "$TELEGRAM_CHAT_ID" ] && echo "TELEGRAM_READY" || echo "TELEGRAM_MISSING"
else
  echo "TELEGRAM_MISSING"
fi

If TELEGRAM_MISSING: Guide the user through setup via AskUserQuestion:

To get daily deadline reminders on Telegram, we need a bot. Here's how to set it up (takes ~2 minutes):

Step 1: Open Telegram and message @BotFather Step 2: Send 

/newbot
and follow the prompts to create a bot Step 3: Copy the bot token @BotFather gives you Step 4: Start a chat with your new bot and send any message Step 5: We'll auto-detect your chat ID

Ready?

  • A) I have my bot token — let me paste it
  • B) Skip Telegram — I'll just use in-session reminders
  • C) I already have TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID in .env

If A: Ask for the token, then detect chat ID:

# After user provides token, get the chat ID from recent messages
TOKEN="{user-provided-token}"
RESPONSE=$(curl -s "https://api.telegram.org/bot${TOKEN}/getUpdates")
echo "$RESPONSE" | python3 -c "
import sys, json
data = json.load(sys.stdin)
if data.get('result'):
    chat_id = data['result'][-1]['message']['chat']['id']
    print(f'CHAT_ID={chat_id}')
else:
    print('NO_MESSAGES')
" 2>/dev/null || echo "PARSE_ERROR"

If chat ID detected, save both to 

.env
:

# Append to .env (create if needed)
echo "TELEGRAM_BOT_TOKEN={token}" >> .env
echo "TELEGRAM_CHAT_ID={chat_id}" >> .env

Send a test message:

TOKEN=$(grep "^TELEGRAM_BOT_TOKEN=" .env | cut -d= -f2-)
CHAT_ID=$(grep "^TELEGRAM_CHAT_ID=" .env | cut -d= -f2-)
curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendMessage" \
  -d chat_id="${CHAT_ID}" \
  -d parse_mode="Markdown" \
  -d text="*actionize* connected! You'll receive daily plan reminders here." \
  > /dev/null 2>&1 && echo "TELEGRAM_OK" || echo "TELEGRAM_FAIL"

If B: Skip to 4B.

If TELEGRAM_READY: Send a test message to confirm the connection still works, then proceed.

4B: Create the Reminder Script

Write the Telegram reminder script to 

.plan/bin/remind.sh
:

mkdir -p .plan/bin

Write this script:

#!/usr/bin/env bash
# .plan/bin/remind.sh — Send plan status to Telegram
# Called by cron or manually

set -euo pipefail
PLAN_DIR="$(cd "$(dirname "$0")/.." && pwd)"
PROJECT_DIR="$(cd "$PLAN_DIR/.." && pwd)"

# Load .env from project root
if [ -f "$PROJECT_DIR/.env" ]; then
  TELEGRAM_BOT_TOKEN=$(grep "^TELEGRAM_BOT_TOKEN=" "$PROJECT_DIR/.env" | cut -d= -f2-)
  TELEGRAM_CHAT_ID=$(grep "^TELEGRAM_CHAT_ID=" "$PROJECT_DIR/.env" | cut -d= -f2-)
fi

if [ -z "${TELEGRAM_BOT_TOKEN:-}" ] || [ -z "${TELEGRAM_CHAT_ID:-}" ]; then
  echo "Telegram not configured. Set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID in .env"
  exit 1
fi

if [ ! -f "$PLAN_DIR/.status.json" ]; then
  echo "No plan found at $PLAN_DIR/.status.json"
  exit 1
fi

TODAY=$(date +%Y-%m-%d)
PLAN_TITLE=$(python3 -c "import json; d=json.load(open('$PLAN_DIR/.status.json')); print(d['title'])")

# Build status message
MSG=$(python3 << 'PYEOF'
import json, sys
from datetime import datetime, date

with open("PLAN_DIR/.status.json".replace("PLAN_DIR", "PLAN_DIR_VALUE")) as f:
    data = json.load(f)

today = date.today()
overdue = []
due_today = []
upcoming = []
completed = 0
total = len(data["tasks"])

for t in data["tasks"]:
    if t["status"] == "completed":
        completed += 1
        continue
    deadline = datetime.strptime(t["deadline"], "%Y-%m-%d").date()
    if deadline < today:
        days_late = (today - deadline).days
        overdue.append(f"  - {t['name']} (due {t['deadline']}, {days_late}d late)")
    elif deadline == today:
        due_today.append(f"  - {t['name']} ({t['effort']})")
    elif (deadline - today).days <= 7:
        upcoming.append(f"  - {t['name']} (due {t['deadline']})")

lines = [f"*{data['title']}* — {completed}/{total} done"]
if overdue:
    lines.append(f"\n🔴 *Overdue ({len(overdue)}):*")
    lines.extend(overdue)
if due_today:
    lines.append(f"\n🟡 *Due today ({len(due_today)}):*")
    lines.extend(due_today)
if upcoming:
    lines.append(f"\n🔵 *Upcoming ({len(upcoming)}):*")
    lines.extend(upcoming)
if not overdue and not due_today and not upcoming:
    if completed == total:
        lines.append("\n✅ All tasks complete!")
    else:
        lines.append("\nNo tasks due this week.")

print("\n".join(lines))
PYEOF
)

# Replace PLAN_DIR_VALUE placeholder
MSG=$(echo "$MSG" | sed "s|PLAN_DIR_VALUE|$PLAN_DIR|g")

# Actually run the python with the correct path
MSG=$(python3 << PYEOF
import json, sys
from datetime import datetime, date

with open("$PLAN_DIR/.status.json") as f:
    data = json.load(f)

today = date.today()
overdue = []
due_today = []
upcoming = []
completed = 0
total = len(data["tasks"])

for t in data["tasks"]:
    if t["status"] == "completed":
        completed += 1
        continue
    deadline = datetime.strptime(t["deadline"], "%Y-%m-%d").date()
    if deadline < today:
        days_late = (today - deadline).days
        overdue.append(f"  - {t['name']} (due {t['deadline']}, {days_late}d late)")
    elif deadline == today:
        due_today.append(f"  - {t['name']} ({t['effort']})")
    elif (deadline - today).days <= 7:
        upcoming.append(f"  - {t['name']} (due {t['deadline']})")

lines = [f"*{data['title']}* \u2014 {completed}/{total} done"]
if overdue:
    lines.append(f"\n*Overdue ({len(overdue)}):*")
    lines.extend(overdue)
if due_today:
    lines.append(f"\n*Due today ({len(due_today)}):*")
    lines.extend(due_today)
if upcoming:
    lines.append(f"\n*Upcoming ({len(upcoming)}):*")
    lines.extend(upcoming)
if not overdue and not due_today and not upcoming:
    if completed == total:
        lines.append("\nAll tasks complete!")
    else:
        lines.append("\nNo tasks due this week.")

print("\n".join(lines))
PYEOF
)

curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  -d chat_id="${TELEGRAM_CHAT_ID}" \
  -d parse_mode="Markdown" \
  -d text="${MSG}" \
  > /dev/null 2>&1

echo "Reminder sent."

Make it executable:

chmod +x .plan/bin/remind.sh

4C: Schedule the System Cron Job

IMPORTANT: Do NOT use CronCreate here — it is session-scoped and dies when Claude exits. Instead, add a real system crontab entry that runs independently.

Check if a crontab entry already exists for this project:

crontab -l 2>/dev/null | grep -q "actionize" && echo "CRON_EXISTS" || echo "CRON_MISSING"

If CRON_MISSING, add the entry. The project path must be absolute:

PROJECT_DIR=$(pwd)
(crontab -l 2>/dev/null || true; echo "# actionize: daily Telegram plan reminder"; echo "3 11 * * * ${PROJECT_DIR}/.plan/bin/remind.sh >> ${PROJECT_DIR}/.plan/cron.log 2>&1") | crontab -

Verify it was added:

crontab -l

Test the script runs successfully standalone:

bash .plan/bin/remind.sh

Tell the user: "System crontab entry added — runs at 11:03am daily, independent of Claude Code. Output logs to 

.plan/cron.log
. On macOS, if reminders don't arrive, check System Settings > Privacy > Full Disk Access for cron. To remove: 
crontab -l | grep -v actionize | crontab -
"

4D: Set Up Session-Start Reminder

To show overdue + today's tasks when Claude Code opens in this project, add a reminder note to CLAUDE.md.

Check if CLAUDE.md already has an actionize reminder:

grep -q "actionize" CLAUDE.md 2>/dev/null && echo "ALREADY_CONFIGURED" || echo "NOT_CONFIGURED"

If NOT_CONFIGURED, append to CLAUDE.md:


## Active Plan

This project has an active action plan in `.plan/`. On session start, read
`.plan/.status.json` and show overdue + today's tasks. Suggest `/actionize`
to review the full plan.

Phase 5: Plan Review & Update

This phase is for updating an existing plan.

Step 5.1: Read 

.plan/.status.json
and all task files in 
.plan/tasks/
.

Step 5.2: Display the full plan status (same format as Phase 0 but with more detail):

PLAN: {title}
Goal: {goal}
Deadline: {deadline}
Progress: {completed}/{total} tasks ({percentage}%)
════════════════════════════════════════

OVERDUE:
  001 - {name} — due {date} ({N} days late)
  ...

DUE TODAY:
  002 - {name} — {effort}
  ...

UPCOMING (next 7 days):
  003 - {name} — due {date}
  ...

PENDING (later):
  004 - {name} — due {date}
  ...

COMPLETED:
  005 - {name} — done {date}
  ...

Step 5.3: Ask via AskUserQuestion:

What would you like to update?

  • A) Mark tasks complete — I finished some tasks
  • B) Adjust deadlines — need to reschedule
  • C) Add new tasks — discovered more work
  • D) Send status now — trigger a Telegram reminder right now

If A: Ask which tasks to mark complete (present as multi-select). Update both the task 

.md
file (Status: completed, add log entry) and 
.status.json
.

If B: Ask which tasks to reschedule. Update deadlines in both files.

If C: Use the same co-design flow from Phase 2 Step 2.3 to add tasks. Assign sequential IDs continuing from the highest existing task number.

If D: Run 

.plan/bin/remind.sh
and show the output.

After any update, ask if the user wants to make more changes (loop) or is done.

Phase 6: Completion

After the plan is saved and reminders are configured:

ACTIONIZE COMPLETE
════════════════════════════════════════
Plan:       {title}
Tasks:      {count} tasks, {date range}
Saved to:   .plan/
Reminders:  Telegram daily at ~11am
Status:     ACTIVE
════════════════════════════════════════

Next steps:
- Mark tasks done from terminal:  .plan/bin/done.sh <id>
- Check progress:                 .plan/bin/done.sh list
- Undo a completion:              .plan/bin/done.sh undo <id>
- Full review via Claude:         /actionize
- Telegram will nudge you daily on overdue items

Suggest relevant next skills:

  • /plan-eng-review
    if the plan involves engineering work
  • /plan-ceo-review
    if it involves strategic decisions
  • /actionize diagnose
    to analyze planning patterns over time
  • Start implementing if the user is ready

Phase 7: Diagnose — Planning Pattern Analysis

This phase is triggered by 

/actionize diagnose
or when the user asks to analyze their planning patterns. It can run project-wide (from within a project) or user-wide (across all projects).

Overview

The diagnose system maintains a user-wide history at 

~/.plan/history.jsonl
that tracks every task across all projects with three states:

  • Planned — tasks that were created and have future deadlines
  • Completed — tasks marked done via 
    done.sh
    or 
    /actionize
  • Deferred — tasks past their deadline that were never completed

It uses InfraNodus to find topical patterns in what the user plans, completes, and defers — revealing blind spots, strengths, and recurring avoidance patterns.

Step 7.0: Sync History

First, sync the current project's task states to the user-wide history:

"${CLAUDE_SKILL_DIR}/bin/sync.sh"

If the user asked for user-wide analysis:

"${CLAUDE_SKILL_DIR}/bin/sync.sh" --all

Step 7.1: Prepare Diagnostic Data

Run the data preparation script:

"${CLAUDE_SKILL_DIR}/bin/diagnose-prep.sh"

Or for a specific project:

"${CLAUDE_SKILL_DIR}/bin/diagnose-prep.sh" --project "ProjectName"

This outputs:

  • ~/.plan/diagnostics/{date}-planned.txt
    — all planned task descriptions
  • ~/.plan/diagnostics/{date}-completed.txt
    — all completed task descriptions
  • ~/.plan/diagnostics/{date}-deferred.txt
    — all deferred task descriptions
  • ~/.plan/diagnostics/{date}-summary.json
    — stats snapshot

Step 7.2: Scope Selection

Ask via AskUserQuestion:

What scope should we analyze?

  • A) This project only — patterns within the current project's plan
  • B) All projects — patterns across everything you've planned (user-wide)
  • C) Compare projects — see how planning patterns differ between projects

Step 7.3: InfraNodus Topical Cluster Analysis

Read the three text files generated in Step 7.1. For each non-empty category, call 

mcp__infranodus__generate_topical_clusters
to discover what topics cluster together.

For planned tasks (what the user aspires to do):

Call 

mcp__infranodus__generate_topical_clusters
with:

  • text: The content of 
    {date}-planned.txt
    (all planned task descriptions, newline-separated)
  • context: "Analyzing planned task descriptions to identify topical clusters in the user's planning patterns across projects."

For completed tasks (what the user actually finishes):

Call 

mcp__infranodus__generate_topical_clusters
with:

  • text: The content of 
    {date}-completed.txt
  • context: "Analyzing completed task descriptions to identify topical clusters in what the user actually accomplishes versus what was planned."

For deferred tasks (what the user consistently avoids):

Call 

mcp__infranodus__generate_topical_clusters
with:

  • text: The content of 
    {date}-deferred.txt
  • context: "Analyzing deferred task descriptions to identify topical patterns in what the user consistently postpones or avoids completing."

Present each cluster analysis with a plain-language interpretation:

  • What you plan: The themes and topics you gravitate toward when planning
  • What you finish: The themes that actually get done — your execution strengths
  • What you defer: The themes you consistently push back — your blind spots

Step 7.4: Gap Analysis via InfraNodus

This is the key insight — comparing planned vs completed reveals what falls through the cracks, and comparing planned vs deferred reveals systematic avoidance patterns.

Planned vs Completed — what you plan but don't finish:

Call 

mcp__infranodus__difference_between_texts
with:

  • contexts: 
    [{ "text": "{planned-text}" }, { "text": "{completed-text}" }]
    (first item is the target to analyze for missing parts; second is the reference)
  • context: "Comparing planned tasks against completed tasks to identify conceptual gaps — topics the user plans for but consistently fails to execute on."
  • modifyAnalyzedText: 
    "detectEntities"

This reveals: topics present in planning but absent from completion. These are systematic execution gaps.

Completed vs Deferred — what separates done from not-done:

Call 

mcp__infranodus__difference_between_texts
with:

  • contexts: 
    [{ "text": "{deferred-text}" }, { "text": "{completed-text}" }]
  • context: "Comparing deferred tasks against completed tasks to understand what conceptual themes distinguish tasks that get done from those that get postponed."
  • modifyAnalyzedText: 
    "detectEntities"

This reveals: what's unique to deferred tasks that's absent from completed ones. These are the characteristics of tasks the user avoids.

Step 7.5: Longitudinal Comparison

Check for previous diagnostic results:

ls -t ~/.plan/diagnostics/*-report.md 2>/dev/null | head -5

If previous reports exist, read the most recent one. Compare current stats (completion rate, deferral rate, topic clusters) against the previous report.

Present trends:

  • Is the completion rate improving or declining?
  • Are the same topics being deferred repeatedly?
  • Have any previously deferred themes moved to completed?

If there are 2+ previous reports, call 

mcp__infranodus__difference_between_texts
comparing the previous deferred topics against the current deferred topics to see if avoidance patterns are shifting or persistent.

Step 7.6: Save Diagnostic Report

Write the full analysis to 

~/.plan/diagnostics/{date}-report.md
:

# Planning Diagnostics — {date}

Scope: {project-wide or user-wide}
Period: {date range of history entries}

## Stats
- Total tasks tracked: {N}
- Completed: {N} ({%})
- Deferred: {N} ({%})
- Planned (active): {N}

## What You Plan (Topic Clusters)
{InfraNodus cluster analysis of planned tasks}

## What You Finish (Topic Clusters)
{InfraNodus cluster analysis of completed tasks}

## What You Defer (Topic Clusters)
{InfraNodus cluster analysis of deferred tasks}

## Execution Gaps (Planned vs Completed)
{difference_between_texts results — topics you plan but don't finish}

## Avoidance Patterns (Deferred vs Completed)
{difference_between_texts results — what distinguishes tasks you avoid}

## Trends
{comparison with previous reports, if available}

## Reflection
{2-3 actionable observations about the user's planning patterns}

Step 7.7: Deliver Insights

Present the report to the user with a structured summary. Focus on actionable insights, not just data. The tone should be reflective and constructive — like a coach reviewing performance, not a judge.

Example delivery:

PLANNING DIAGNOSTICS
════════════════════════════════════════
Completion rate: 67% (up from 55% last week)
Deferral rate:   25%

WHAT YOU FINISH:
  Backend infrastructure, data pipelines, testing
  → You execute well on technical foundation work

WHAT YOU DEFER:
  UI polish, documentation, user-facing design
  → Frontend and docs consistently slip past deadlines

EXECUTION GAP:
  You plan "text analysis" and "visualization" but
  complete "schema" and "data pipeline" — the analytical
  backend gets done, the presentation layer doesn't.

RECOMMENDATION:
  Front-load one UI task per week before backend work.
  Your deferred items suggest avoidance of visual/design
  decisions, not lack of time.
════════════════════════════════════════

Ask via AskUserQuestion:

Based on this analysis, would you like to adjust your current plan?

  • A) Yes — rebalance deadlines based on these patterns
  • B) Save and continue — I'll think about this
  • C) Send to Telegram — push this summary to my Telegram
  • D) Run deeper analysis — I want to explore a specific pattern

If C: send via Telegram using the remind.sh pattern (curl to Bot API). If D: ask what pattern to explore, then use 

mcp__infranodus__generate_research_questions
on that subset.

Phase 8: Diagnose Cron — Automated Sync + Nudge

During Phase 4 (reminder setup), also set up a 3-day sync cron. This runs 

sync.sh --all
to detect newly deferred tasks across all projects, then sends a Telegram message nudging the user to run 
/actionize diagnose
.

Check if the diagnostics cron already exists:

crontab -l 2>/dev/null | grep -q "actionize-diagnose" && echo "DIAG_CRON_EXISTS" || echo "DIAG_CRON_MISSING"

If DIAG_CRON_MISSING, add it alongside the daily reminder:

SKILL_DIR="${CLAUDE_SKILL_DIR}"
PROJECT_DIR=$(pwd)
(crontab -l 2>/dev/null || true; echo "# actionize-diagnose: sync + nudge every 3 days"; echo "17 11 */3 * * ${SKILL_DIR}/bin/sync.sh --all && ${SKILL_DIR}/bin/diagnose-nudge.sh") | crontab -

The nudge script sends a short Telegram message: "You have N deferred tasks across M projects. Run /actionize diagnose for pattern analysis."

Important Rules

  • Never implement. This skill produces plans, not code.
  • Questions ONE AT A TIME. Never batch multiple questions into one AskUserQuestion.
  • Dates are absolute. Always use YYYY-MM-DD format. Never store relative dates.
  • Plans are personal. Add 
    .plan/
    to 
    .gitignore
    — plans are not committed.
  • Telegram is optional. The skill works without it — in-session reminders still function.
  • Status.json is the source of truth. Always update it alongside task markdown files.
  • Completion status:
    • DONE — plan created/updated, reminders configured
    • DONE_WITH_CONCERNS — plan created but Telegram setup failed
    • BLOCKED — cannot parse input or user cannot decide on goal
    • NEEDS_CONTEXT — insufficient insights to create a meaningful plan