Work

📋 Work: Plan Execution Engaged

Track tasks, manage plans, and survive CC compacts with three operating modes.

Activation

When this skill activates, output:

📋 Work: Plan execution engaged.

Then determine which mode to use based on the trigger.

Context Guard

Step 0: Silent Context Compilation (MANDATORY)

Before executing ANY mode, silently gather current state. Do NOT present findings. Do NOT ask questions. Just internalize:

1. Read the project's STATE.md (if it exists): current task, blockers, next steps
2. Read the project's CLAUDE.md (if it exists): conventions, architecture decisions
3. Check recent diary:

   python "${CLAUDE_PLUGIN_ROOT}/db/memstack-db.py" get-sessions <project> --limit 3
   

4. Check git state:

   git log --oneline -5
   git diff --stat
   

This is silent. Synthesize an internal understanding of where the project stands. Then proceed to the triggered mode with full context. The user already knows their project state, don't waste their time repeating it back.

Mode 1: Copy Plan

Trigger: "copy plan" or when a new plan is provided

1. Parse the entire plan into individual numbered tasks

2. For each task, save to SQLite:

   Write the payload to a file, then pipe it in with - as the argument. A payload on stdin is never seen by the shell's parser, so a redirection operator inside a task description cannot be read as one.

   cat task.json | python "${CLAUDE_PLUGIN_ROOT}/db/memstack-db.py" add-plan-task -
   

   task.json contains:

   {"project":"<name>","task_number":<n>,"description":"<task>","status":"pending"}
   

3. Confirm with task count

4. Also write a markdown copy to memory/projects/{project}-plan.md for human readability

Status values: pending, in_progress, completed, blocked

Mode 2: Append Plan (Update Tasks)

Trigger: "append plan" or when updating task statuses

1. Read current plan from SQLite:

   python "${CLAUDE_PLUGIN_ROOT}/db/memstack-db.py" get-plan <project>
   

2. Update individual task statuses:

   Same form, even though this payload is only metadata. One rule with no exceptions is easier to follow than a rule you have to judge.

   cat task-update.json | python "${CLAUDE_PLUGIN_ROOT}/db/memstack-db.py" update-task -
   

   task-update.json contains:

   {"project":"<name>","task_number":<n>,"status":"completed"}
   

3. Add new tasks if needed via add-plan-task

4. No size limits needed: SQLite handles scale

Mode 3: Resume Plan

Trigger: "resume plan", use after CC compact or new session

1. Load plan from SQLite:

   python "${CLAUDE_PLUGIN_ROOT}/db/memstack-db.py" get-plan <project>
   

2. Parse the JSON output for task statuses
3. Output a summary:

   Plan: {project} ({done}/{total} complete)
   
   Completed: [list]
   In Progress: [list]
   Pending: [list]
   Blocked: [list with reasons]
   
   Recommended next: {first pending task}
   

4. Continue from the first incomplete task

Quick Commands

• "what's next": queries plan, returns the single next pending task
• "priorities": shows top 3 pending items from the plan
• "todo": shows all pending and in-progress items with status

Inputs

• Plan text (copy mode) or project name (append/resume)
• Database: ~/.memstack/memstack.db (via memstack-db.py)
• Fallback: $MEMSTACK_PATH/memory\projects\ (legacy markdown)

Outputs

• Formatted task list with status indicators
• Updated plan file in memory
• Next recommended action

Example Usage

User: "resume plan for AdminStack"

📋 Work: Plan execution engaged.

Plan: AdminStack (5/9 complete)

[x] 1. Build CC Monitor page
[x] 2. Add setup guide
[x] 3. Fix API key validation
[x] 4. Add refresh feedback
[x] 5. Update guide with curl snippet
[ ] 6. Build cc-reporter.js Node script
[ ] 7. Add WebSocket real-time updates
[ ] 8. Session grouping by project
[!] 9. Mobile polish (blocked: waiting for design specs)

Recommended next: Task 6: Build cc-reporter.js

Level History

• Lv.1: Base: Single-mode TODO tracking. (Origin: MemStack v1.0, Feb 2026)
• Lv.2: Enhanced: Three modes (copy/append/resume), 1K-line limit with auto-summarize, context guard, YAML frontmatter. (Origin: MemStack v2.0 MemoryCore merge, Feb 2026)
• Lv.3: Advanced: SQLite-backed plans with per-task status tracking, no size limits, structured queries. (Origin: MemStack v2.1 Accomplish-inspired upgrade, Feb 2026)
• Lv.4: Native: CC rules integration (.claude/rules/work.md), always-on task planning awareness without skill file read. (Origin: MemStack v3.0-beta, Feb 2026)
• Lv.5: Context-aware: Silent context compilation (Step 0): reads STATE.md, CLAUDE.md, recent diary, and git state before any operation. Inspired by Intellegix silent pre-flight pattern. (Origin: MemStack v3.2, Feb 2026)