Ccs Align

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

As of this sign-off, the repo (package, plugin, marketplace) is at 13.24.5 (this Phase 3 PATCH), but the running worker plugin on the house box may still be 13.24.1. That is an operational MISS to record, not fix here: this seat does not restart or upgrade the worker (a hard forbid). If the live box still shows 13.24.1, note it when rolling status up to the Prioritizer so the worker gets restarted onto the current plugin out-of-band. If the running worker already matches the package version, this MISS is closed.

Prerequisites

The claude-mem worker must be running locally. This seat talks to the local worker (per-UID port ~37700), never the cloud CMEM MCP — cloud observation:<base64> ids are a different API and must not be mixed in.

Resolve the worker port once and reuse $WORKER_PORT in every curl below. This snippet is copied from the timeline-report skill and honors CLAUDE_MEM_WORKER_PORT → ~/.claude-mem/settings.json → the per-UID default 37700 + (uid % 100):

WORKER_PORT="${CLAUDE_MEM_WORKER_PORT:-$(node -e "const fs=require('fs'),p=require('path'),os=require('os');const uid=(typeof process.getuid==='function'?process.getuid():77);const fallback=String(37700+(uid%100));try{const s=JSON.parse(fs.readFileSync(p.join(os.homedir(),'.claude-mem','settings.json'),'utf-8'));process.stdout.write(String(s.CLAUDE_MEM_WORKER_PORT||fallback));}catch{process.stdout.write(fallback);}" 2>/dev/null)}"

Do not hardcode port 37777 — ports are per-UID.

Settings

Defaults live in SettingsDefaultsManager.ts; override in ~/.claude-mem/settings.json:

Pilot viewer id is ccs-align. The seat may read LFG observations (agent id 521e962d-2ec3-4488-bfbc-54d5209ce118) as a project filter, but must not write LFG/Orifice monthly logs or any profile.md.

Hourly cycle (Appendix A runbook)

Run this every hour on a weekday house board. One purpose. No watercooler. No "while I was here I also…".

every hour (weekday house board):
  1. Resolve WORKER_PORT (snippet above)
  2. GET /api/health || GET /health   → abort with a one-line miss if down
  3. search(obs_type=needles, limit=20) since cursor.lastObservationId
  4. timeline(anchor=newest)          → collect neighbor ids
  5. get_observations(ids=…)
  5b. (Phase 1, mark-time only) If excluding: get_tool_uses for tool ids → record on mark
  6. grab middle.jsonl → append new → filter exclude-marks → replace atomic
  7. if original-cache path set and not writable: append-only to middle.jsonl (already done)
  8. update cursor.json
  9. every 6th hour: rules walk → append rules-report.md   (Phase 2 — see below)
 10. Speak to Alex only on red (worker down, write refused, unexpected profile.md touch)

Step 1 — Resolve the port

Use the $WORKER_PORT snippet above.

Step 2 — Prove worker health (prefer /api/health)

Prefer GET /api/health; also accept the viewer alias GET /health. The public worker docs still show GET /health and a port field — both are stale. Health does not return a port; use GET /api/stats (worker.port) if you need it.

curl -sS "http://127.0.0.1:${WORKER_PORT}/api/health" || curl -sS "http://127.0.0.1:${WORKER_PORT}/health"
# expect a JSON body with "status":"ok". If the worker is down, abort with a
# one-line miss — do NOT start it, do NOT retry aggressively.

If health cannot be proven (e.g. no live worker in a cloud VM), record a MISS and stop. Do not fabricate a cache cycle.

Step 3 — Pull through the three-layer ladder (in order)

The disclosure order is search → timeline → get_observations. Never jump straight to get_observations, and do not call get_tool_uses in Phase 0 (that is Phase 1).

1. search with the needle obs_type list (CLAUDE_MEM_CCS_ALIGN_TRIGGER_TYPES), limit ≤ 20, optionally scoped by project. Use the cursor's lastObservationId to avoid re-pulling the whole diary.

   curl -sS "http://127.0.0.1:${WORKER_PORT}/api/search?query=*&type=decision&limit=20&format=json"

2. timeline anchored on the newest hit. The worker's code default depth is 10 (SearchManager.ts) — the MCP text that says "3" is stale, so omit the depths (worker applies 10) or pass 10 explicitly.

   curl -sS "http://127.0.0.1:${WORKER_PORT}/api/timeline?anchor=<newestObservationId>"

3. get_observations for the ids you will actually cache.

   curl -sS -X POST "http://127.0.0.1:${WORKER_PORT}/api/observations/batch" \
     -H 'content-type: application/json' \
     -d '{"ids":[12345,12346]}'

The MCP twins are search → timeline → get_observations. Worker get_observations ids are numbers; do not pass cloud observation:<base64> ids into /api/observations/batch.

Step 4 — Grab → append → filter exclude-marks → replace (atomic middle cache)

Land the observations with the seat helper src/services/integrations/CcsAlignMiddleCache.ts (landObservationsInMiddleCache). It copies the #3931 atomic primitive (appendAwarenessLineAtomic + awarenessLineBody) with exactly three changes: the tag is [ccs-align], the path root is ~/.claude-mem/ccs-align/<viewerId>/, and the file is middle.jsonl.

Phase 1 adds an exclude-marks filter inside the atomic pipeline:

grab:    read middle.jsonl if it exists, else empty
filter:  load exclude-marks.json; drop any record whose id is marked
append:  for each new observation id not already present AND not marked, append one record
replace: write temp + rename (copy appendAwarenessLineAtomic; never appendFileSync)
fallback: if an OPTIONAL original-cache path is set and not writable, skip grab/replace
          on that path and append timeline items to middle.jsonl only

There is no compiled laminate file in-repo, so the fallback resolves to "append to the seat file" — never invent a laminate.

Each line of middle.jsonl is one record. The shape is locked for Phase 0 (do not add fields):

{
  "v": 1,
  "id": 12345,
  "type": "decision",
  "title": "…",
  "created_at": "2026-09-09T00:00:00.000Z",
  "project": "claude-mem",
  "agent_id": null,
  "source": "worker",
  "line": "- 2026-09-09 [ccs-align] decision — «…»"
}

line is formatCcsAlignLine: the awareness line format with the tag swapped, written by the same shared formatter, so the recalled text is sanitized (no tag framing or invisible characters) and fenced in «…», truncated inside the fence to 500 chars. Dedupe is by observation id and by body (the line from [ccs-align] onward, date excluded), so the same fact on a new day is still skipped and the file does not grow on a repeat cycle.

A minimal invocation (bun/node):

import { landObservationsInMiddleCache } from '../../src/services/integrations/CcsAlignMiddleCache.js';

landObservationsInMiddleCache({
  viewerId: 'ccs-align',
  observations: rowsFromGetObservations, // [{ id, type, title, subtitle, facts, created_at, project, agent_id }]
});

It never throws into the caller — a broken write path is logged and swallowed.

Step 5 — Update the cursor

Write ~/.claude-mem/ccs-align/<viewerId>/cursor.json so the next hour does not re-pull the whole diary:

{ "lastRunAt": "…", "lastObservationId": 12345, "healthPath": "/api/health", "workerPort": 37700 }

Use writeCursor from the helper (atomic temp + rename).

Step 6 — Speak only on red

Roll status up to the Prioritizer. Only speak to Alex on red: worker down, a write was refused, or an unexpected profile.md touch. Otherwise stay quiet.

Phase 1 — Exclude marks

"Purge" means the compiled middle.jsonl no longer contains the observation or its tool I/O for that viewer. The diary stays. This is Secure Isolated Awareness + context-stripper — not delete.

Exclude-marks file

Each viewer has ~/.claude-mem/ccs-align/<viewerId>/exclude-marks.json:

{
  "v": 1,
  "marks": [
    {
      "observationId": 12345,
      "toolUseIds": ["toolu_01abc", 678],
      "reason": "sibling-wall|manual|stripper|secure-isolation",
      "markedAt": "2026-09-09T00:00:00.000Z",
      "markedBy": "ccs-align"
    }
  ]
}

Marks are managed by addExcludeMark / removeExcludeMark in CcsAlignMiddleCache.ts, or by manual JSON edit.

How marks get created (v1)

1. Manual JSON edit — open exclude-marks.json and add a mark entry.
2. Skill flag — exclude <observationId> --reason … (manual, sibling-wall, stripper, secure-isolation).
3. No auto-promotion from chat text (poison surface — see Memory dig findings).

Purge tools (compiled only)

When recording tool-use ids on a mark:

1. After get_observations, if you need tool ids, call get_tool_uses / POST /api/tool-uses/batch (layer 4).
2. Record those ids on the mark's toolUseIds array.
3. Never persist raw tool_input / tool_response into middle.jsonl — layer 4 stays out of the laminate.
4. Do not call DELETE /api/observation/:id — that tombstones the diary and breaks rebuild-from-history.

Warning: get_tool_uses is layer 4 of the progressive disclosure ladder. It returns raw tool I/O and should only be called at mark-time to capture tool-use ids for an exclude mark. Never call it during the normal hourly cycle. Never persist its tool_input / tool_response payloads into any cache file.