Skip to content
Skillpedia
Agents101k · #808

ccs-align

Lets your agent run a Claude-Mem health check cycle. It ensures the local worker is functioning and detects conflicts.

What it does

Checks the health of the local 'claude-mem' program, collects recent information, and organizes it into a cache (a temporary storage location). It also checks for conflicts between defined rules.

When to use it

  • ✓To ensure the 'claude-mem' program is running correctly.
  • ✓To collect and organize recent usage data.
  • ✓To identify issues or inconsistencies in operational rules.

Example of what to ask your AI

“Alex, check the health of my 'claude-mem' program and organize recent information.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/thedotmack/claude-mem/blob/main/plugin/skills/ccs-align/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/thedotmack/claude-mem/blob/main/plugin/skills/ccs-align/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It runs a cycle every hour to check the local program, fetch data, and save it to a temporary location. Then, it compares this data with rules to find potential conflicts.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add thedotmack/claude-mem --skill ccs-align

Or download just the file:

curl -L https://raw.githubusercontent.com/thedotmack/claude-mem/main/plugin/skills/ccs-align/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

CCS Align — Worker Watch seat (Phases 0–2 shipped; Phase 3 = verify / sign-off)

CCS Align is a standing seat, not a bird's-eye planner. Its one job, once an hour: talk to the local claude-mem worker, pull recent needle observations through the existing three-layer disclosure ladder, and land them in a seat-owned middle cache using grab → append → replace.

This skill implements the Phase 0 breathing slice, Phase 1 exclude marks, and Phase 2 rules alignment from the plan of record, plans/2026-09-09-ccs-align.md. Phases 0–2 are shipped and merged (#3934, #3935, #3936); Phase 3 is verify / sign-off (this loop) — no new product surface. It is not a context compiler, not Focus/mouth, and not Grok Memory Phase 2. When you speak to the human, address them as Alex.

What is implemented (Phases 0–2 shipped)

  • Phase 0 — Breathing slice (#3934): health check → search → timeline → get_observations → append records to ~/.claude-mem/ccs-align/<viewerId>/middle.jsonl (atomic, deduped).
  • Phase 1 — Exclude marks (#3935): mark observations (and linked tool-use ids) as excluded from the compiled middle cache. "Purge" means the compiled middle.jsonl no longer contains the record — the diary / SQLite stay authoritative. Unmarking + rebuild restores the observation. DELETE /api/observation/:id is forbidden.
  • Phase 2 — Rules alignment (#3936): walk house → project → seat layers, detect conflicts (SHADOW_HOUSE, DENY_ALLOW, DRIFT, CLOCK_HEADER), emit an append-only rules-report.md. Optionally dry-run/apply SHADOW_HOUSE leaf patches when CLAUDE_MEM_CCS_ALIGN_PATCH_SHADOWS=true. Runs every 6th hour of the hourly Worker Watch cycle (D4). This is a checklist, not a parser — no .cas compiler.
  • Phase 3 — Verify / sign-off (this loop): re-run the regression tests and anti-pattern greps, prove the boundary (a scripted cycle dedupes, an exclude drops from the middle cache but not the diary, the rules report is produced or a MISS is recorded), and keep the skill + plan honest about what this seat is not. Phase 3 adds no new runtime behavior.
  • Does not: delete history, write profile.md, write LFG/Orifice [awareness] logs (that seam belongs to #3931), add a sixth processAgentResponse consumer, restart the worker, run a per-turn drip update, enforce Focus/mouth/standing rules, or copy house text into seats.

What this is NOT (honest boundary)

CCS Align is deliberately small. It does not ship, and this loop does not add, any of the following — these are future work or a different agent, called out so no one reads more into the seat than is there:

  • No context compiler. There is no .cas parser, no compileAwareness(), no JIT compile, no computed-styles UI. The CCS Notion page types (Bucket, canRead) are teaching copy quoted as comments — never a runtime parser.
  • No brainbeat product. The "regenerate awareness once per finished unit of work" door is not built. Align pulls on an hourly cadence; it is not a per-turn drip and it is not a brainbeat.
  • No attention trough / curse-salience. No salience decay, no trough scoring. Explicitly out of every phase.
  • No Focus / mouth enforcement. Standing rules (always / never / danger) are never enforced or decayed here. Align may list a conflict; egress filtering belongs to a different agent.
  • No second writer on LFG/Orifice [awareness] logs. #3931 owns agents/**/memory/log/YYYY-MM.md. Align writes only its seat-owned middle cache.
  • No history rewrite. Exclude marks filter the compiled cache; the diary / SQLite stay authoritative and rebuildable. No DELETE /api/observation, no A-MEM row rewrite.

Ops MISS — worker plugin version lag

…

FAQ

What is a 'standing seat'?

It's a program that runs at regular intervals (in this case, hourly) to perform a specific task, rather than being triggered by an event.

What are 'needle observations'?

These are specific pieces of data or information collected by the 'claude-mem' program.

What does 'atomic grab -> append -> filter exclude-marks -> replace' mean?

It's the process of safely acquiring data, adding new data, removing items marked for exclusion, and then updating the storage.

Details

Original description by the author

Run the CCS Align seat's hourly breathing cycle — prove the local claude-mem worker is healthy, pull needle observations through search → timeline → get_observations, land them in a seat-owned middle cache via atomic grab → append → filter exclude-marks → replace, manage exclude marks, and walk house → project → seat rules to detect conflicts (SHADOW_HOUSE, DENY_ALLOW, DRIFT, CLOCK_HEADER) with an

repo: thedotmack/claude-mem

Popularity

GitHub stars
101k
Ranking position
#808
License
Apache-2.0
Updated
10/16/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills