Compact Now

What it does

When your agent uses it

• The operator says /compact-now / compact now
• Chrono has flagged context pressure against shared/lifecycle.md rule 8

Example prompts

• “/compact-now”
• “compact now”
• “/compact-now”

Requirements

• Python 3

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

1. 1Reads the live board partition via chrono_state.registry.registry_view() and confirms no
2. 2If blockers exist (live dispatches), surfaces them to the operator and asks whether to proceed
3. 3Externalizes load-bearing state to the Vault via the current record("learning", {...}) writer — captures active decisions (authority)…
4. 4Snapshots the same state to _state/chrono/compaction/.json via chrono_state.compaction.snapshot().
5. 5Invokes Claude Code's native /compact.
6. 6After compact, reads the snapshot via chrono_state.compaction.recover() and re-anchors on the next operator turn — never bulk-re-reading…

What it can do on your machine

Read from SKILL.md and the folder at commit 7bd69f8. It shows what the files ask for, not the result of running them.

• Tool permissions

  Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  No scripts in the folder and no shell commands in SKILL.md (its code samples are python).

  From the folder's file list and the shell code blocks in SKILL.md.

• Network

  No URLs in SKILL.md.

  From URLs in SKILL.md, links to its own repository left out.

• Credentials

  Names no API keys, tokens, secrets or passwords.

  From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Compact Now loads about 1.6k tokens when it runs. Until then it costs about 100 tokens; SKILL.md has 346 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~100

When it runs · the whole SKILL.md, loaded when a task matches

~1.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from mtarcure/claude-vibe-squad at commit 7bd69f8, republished under its MIT licence (© mtarcure). 346 words, ~1,561 tokens.

name

compact-now

description

Operator-triggered proactive compaction — Chrono externalizes load-bearing state (active decisions, open tasks, next action) to a snapshot + a durable Vault learning note before invoking Claude Code's native /compact, then resumes from the snapshot. Use when the operator says "/compact-now" / "compact now" or when Chrono has flagged context pressure against shared/lifecycle.md rule 8.

type

skill

# Chrono inline (not dispatched)
import json, sys
sys.path.insert(0, "scripts/python")
from chrono_state.compaction import snapshot                   # noqa: E402
from chrono_state.registry import registry_view                # noqa: E402
from chrono_state.decisions import active_decisions            # noqa: E402

# ONE classification pass over the LIVE registry (_state/active-tasks.json).
# registry_view() is the current API for this gate. The dead bounded-registry helper
# load_active() was removed; it read _state/tasks/active.json, which the live board
# does not feed. registry_view() partitions by the real vocabulary in
# registry.LIVE_STATUSES / DEFERRED_STATUSES; never hand-write status literals here,
# or the gate filters on a status the board does not emit and passes vacuously.
board = registry_view()

# Live work is a hard blocker and IS mechanical -- the board knows it, so ask the
# board. Whether context pressure warrants compacting at all is Chrono's judgment
# against shared/lifecycle.md rule 8; there is no predicate for it and no token
# counter to feed one (rule 9: proxy signals only).
blockers = [t["id"] for t in board["live"]]
if blockers:
    surface_to_operator(f"Blockers: {blockers}. Proceed anyway?")
    if not operator_confirms:
        return
# An unclassified status is owed work the partition cannot see — surface it loudly
# rather than compacting over it (same contract as the resume capsule).
if board["unclassified"]:
    surface_to_operator(f"UNKNOWN registry statuses: {board['unclassified']}. Proceed anyway?")

state = {
    "next_action": next_action,
    "active_decisions": active_decisions(),   # AUTHORITY — not Vault evidence
    "active_tasks": board["live"],
    "deferred_tasks": board["deferred"],      # owed work; stalled, not executing
    "latest_turn": latest_operator_turn,
    "pending_approvals": pending_approvals,
}

# 1) Durable Vault note via the CURRENT API — record(note_type, fields), NOT the stale
#    record_finding(role=, canonical_name=, ...) signature. fields require title/body/
#    target/attack_class; unknown fields are rejected.
mcp__chrono_vault__record("learning", {
    "title": f"compact-now externalization ({session_id})",
    "body": json.dumps(state, indent=2),
    "target": "chrono-orchestrator",
    "attack_class": "session-continuity",
    "keywords": ["compaction", "resume", "chrono"],
    "source_task": current_task_id,
})

# 2) Atomic snapshot to _state/chrono/compaction/<session>.json
snapshot(session_id, state)

# 3) Invoke Claude Code's native /compact
trigger_native_compact()

# 4) After compact: recover ONLY from the snapshot, never bulk-re-read history.
#    from chrono_state.compaction import recover; recover(session_id)

© mtarcure, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/chrono-vault/skills/compact-now of mtarcure/claude-vibe-squad.

Open the folder on GitHubat commit 7bd69f8