strategic-compact

Track tool call counts and recommend manual compaction at logical task boundaries.

Updated Mar 26, 2026
One-click install
npx skills add https://github.com/luongldptit/move-ticket --skill strategic-compact-luongldptit
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: strategic-compact
Source: https://github.com/luongldptit/move-ticket/tree/main/.agent/.agents/skills/strategic-compact
Command: npx skills add https://github.com/luongldptit/move-ticket --skill strategic-compact-luongldptit

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Auto-compaction in long AI assistant sessions often triggers at arbitrary mid-task points, leading to loss of critical context like variable names, partial implementation state, and recent reasoning that is still needed for ongoing work.

Core Features & Use Cases

  • Strategic Compaction Suggestions: Recommends manual /compact only at logical task boundaries (after research, post-milestone, before task switches) to avoid discarding still-relevant context.
  • Configurable Reminder Hook: Tracks tool call counts to send timely compaction reminders, with adjustable thresholds via environment variables.
  • Compaction Decision Guide: Provides a clear reference to help you distinguish safe compaction points (e.g., after finalizing a plan) from disruptive ones (e.g., mid-implementation).
  • Use Case: A developer working on a multi-phase feature (research → plan → implement → test) can use this Skill to get a reminder to compact after locking in their implementation plan, starting the coding phase with a fresh context window without losing the finalized plan.

Quick Start

Use the strategic-compact skill to receive timely suggestions for when to run manual /compact during long or multi-phase work sessions to preserve important context across task boundaries.

Frequently Asked Questions about strategic-compact

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I preserve context in long AI assistant sessions without losing critical implementation state?

To preserve context in long AI assistant sessions, you can use strategic manual compaction at logical task boundaries. This prevents arbitrary auto-compaction from discarding active variables, partial implementation state, and recent reasoning needed for ongoing work.

When should I manually compact context during a multi-phase development workflow?

You should manually compact context during a multi-phase development workflow at logical task boundaries, such as after research, post-milestone, or before task switches. The compaction decision guide helps distinguish these safe points from disruptive mid-implementation moments.

Why does auto-compaction disrupt ongoing coding tasks in extended workflows?

Auto-compaction disrupts extended coding workflows because it triggers at arbitrary context limits rather than logical boundaries. This causes the loss of critical active context like variable names, recent reasoning, and partial implementation state still required to complete the current task.

Can I get reminders to compact context before hitting auto-compaction limits?

Yes, you can receive reminders to compact context by using a configurable hook that tracks tool call counts. It sends timely compaction reminders at adjustable thresholds via environment variables to trigger manual context preservation before arbitrary auto-compaction occurs.

What is the best way to manage context pressure during intra-session task switches?

The best way to manage context pressure during intra-session task switches is to run a manual compact command after finalizing the previous phase. This starts the next task with a fresh context window while preserving the finalized plans or milestones.

Are there limitations to using strategic compaction for context management?

A limitation of strategic compaction is that it requires manual intervention and decision-making to identify safe boundaries. Users must actively evaluate whether a transition point is truly safe, as compacting mid-implementation can still result in the loss of critical active reasoning.