meridian-dev 1.1.0

package/specializations/cursor/README.md

@@ -0,0 +1,112 @@
+# Cursor Integration — Skip Tissue
+
+Full setup guide for Cursor users.
+
+## Quick Setup
+
+Run the main installer and choose Cursor when prompted:
+```bash
+bash setup.sh --tool cursor
+```
+
+Or manually follow the steps below.
+
+## How It Works
+
+Cursor injects rule files into the AI context at session start. The memory kit hooks into this system to load your state files automatically.
+
+### Memory Directory
+
+The Cursor specialization uses `~/.ai-memory/` as the memory root (tool-agnostic, not tied to Cursor's config location):
+
+```
+~/.ai-memory/
+  global.md              # Always loaded — thin index of all state
+  state.md               # Admin/non-repo work
+  memory/
+    <topic>.md           # Loaded on demand
+    journal/
+      YYYY-MM-DD.md      # Daily session log
+```
+
+### Per-Repo Files
+
+```
+<repo>/.cursor/
+  rules/
+    memory.mdc           # Repo-level memory rules (committed to git)
+```
+
+### Session Flow
+
+**Session start:** Cursor reads `.cursor/rules/memory.mdc` → AI loads `~/.ai-memory/global.md` + repo state
+
+**Session end (manual):** Say "done for today, update state files" — the AI updates the state files and appends a journal entry
+
+## Setup
+
+### Step 1: Memory directory
+
+```bash
+mkdir -p ~/.ai-memory/memory/journal
+```
+
+### Step 2: Global index
+
+```bash
+cp templates/global.md ~/.ai-memory/global.md
+# Edit with your preferences, projects, team context
+```
+
+### Step 3: Global Cursor rules
+
+Cursor supports global rules in `~/.cursor/rules/`. Create the memory rule:
+
+```bash
+mkdir -p ~/.cursor/rules
+cp specializations/cursor/global-rule.mdc ~/.cursor/rules/ai-memory.mdc
+```
+
+### Step 4: Initialize a repo
+
+In any repo you work in with Cursor, run:
+
+```bash
+bash setup.sh --tool cursor --repo .
+# Or manually:
+mkdir -p .cursor/rules
+cp specializations/cursor/repo-rule.mdc .cursor/rules/memory.mdc
+```
+
+Edit `.cursor/rules/memory.mdc` to reflect the repo name and what it's about.
+
+### Step 5: Fill in your global index
+
+Open `~/.ai-memory/global.md` and fill in:
+- Your preferences and working style
+- Active projects table
+- Team context (using the examples as a guide)
+
+## Session End Triggers
+
+Since Cursor has no native hooks, use these natural language triggers to end a session:
+
+- "done for today" — triggers state file updates + journal entry
+- "stop, update memory" — same
+- "save session state" — same
+
+The rule file instructs the AI to perform all updates when it hears these phrases.
+
+## What Gets Committed
+
+- `.cursor/rules/memory.mdc` — **commit this** (shared context for any AI tool that reads the repo)
+- `~/.ai-memory/` files — **never commit** (personal memory, lives outside the repo)
+
+## Limitations vs. Claude Code
+
+| Feature | Claude Code | Cursor |
+|---------|------------|--------|
+| Auto session-start | ✓ Hook fires automatically | ✓ Rule file injected automatically |
+| Auto session-end | ✓ Hook triggers on stop | ✗ Manual trigger required |
+| `/init-memory` command | ✓ | ✗ Use `setup.sh --tool cursor --repo .` |
+| Global memory path | `~/.claude/` | `~/.ai-memory/` |

package/specializations/cursor/global-rule.mdc

@@ -0,0 +1,53 @@
+---
+description: Skip Tissue — Session Protocol (Global)
+alwaysApply: true
+---
+
+## Session State Protocol
+
+**Memory system:** Hierarchical plain-markdown files at `~/.ai-memory/`. No CLI tools, no databases.
+
+### File Hierarchy
+
+```
+~/.ai-memory/
+  global.md            # Thin index — ALWAYS load at session start
+  state.md             # Admin/non-repo work
+  memory/              # Topic files — load on demand
+    <topic>.md
+    journal/YYYY-MM-DD.md  # Daily log
+```
+
+### Session Start (REQUIRED)
+
+1. Read `~/.ai-memory/global.md`
+2. Read `.cursor/rules/memory.mdc` in the current repo for repo-specific context
+3. Check the Memory Files table in `global.md` — load any `~/.ai-memory/memory/` files whose keywords match this session's topic
+4. Summarize current state, then ask: **"What's the goal for this session? What does success look like?"**
+
+### Mid-Session
+
+If work drifts from the stated goal, flag it: *"Quick check — we set out to [goal]. This feels like [tangent]. Stay the course or pivot?"*
+
+### Session End Triggers
+
+When the user says "done", "stop", "done for today", "save session state", or "update memory":
+
+1. Update `<repo>/.cursor/rules/memory.mdc` with current branch, status, next steps
+2. Update the Active Projects row in `~/.ai-memory/global.md`
+3. Create/update topic files in `~/.ai-memory/memory/` for significant new cross-repo context
+4. Append to `~/.ai-memory/memory/journal/YYYY-MM-DD.md`:
+   ```
+   ## [Repo] — [Title]
+   **Why:** [Stated goal]
+   **What:** [What was done]
+   **Outcome:** [Did we hit it?]
+   **On track?:** [Focused or drift?]
+   **Lessons:** [Cross-session learnings]
+   ```
+5. Confirm: **"State saved. Say 'let's continue' next time."**
+
+### Rules
+
+- Keep `global.md` under 80 lines. Detail goes in `~/.ai-memory/memory/` files.
+- Do NOT use any CLI memory tools — plain markdown files only.

package/specializations/cursor/repo-rule.mdc

@@ -0,0 +1,25 @@
+---
+description: Skip Tissue — Repo State ([REPO_NAME])
+alwaysApply: true
+---
+
+## Repo State: [REPO_NAME]
+
+Last updated: YYYY-MM-DD
+
+### Current Branch
+[branch]
+
+### Current Status
+[what's happening in this repo]
+
+### What's Next
+[concrete next action]
+
+### Gotchas
+[anything to know before diving in]
+
+---
+
+*This file is maintained by the AI. Update it at session end.*
+*Global memory lives at `~/.ai-memory/global.md`.*

package/specializations/generic/README.md

@@ -0,0 +1,47 @@
+# Generic Specialization
+## Any AI Tool with System Prompt Support
+
+If your tool doesn't have a file-based instruction system, you can still use this kit by pasting the session protocol into your system prompt or the beginning of each conversation.
+
+## Option 1: System Prompt Injection
+
+Paste the contents of `../../templates/session-protocol-fragment.md` into your tool's system prompt field. Adjust the memory directory path from `~/.ai-memory/` to wherever you want to store the files.
+
+## Option 2: Conversation Starter
+
+If your tool has no persistent system prompt, start each session with:
+
+```
+Before we begin: read ~/.ai-memory/global.md and .ai-memory/state.md in this repo.
+Summarize where we left off, then ask what the goal is for this session.
+```
+
+## Memory Directory
+
+Use `~/.ai-memory/` as a tool-neutral memory root:
+
+```bash
+mkdir -p ~/.ai-memory/memory/journal
+cp ../../templates/global.md ~/.ai-memory/global.md
+```
+
+## Session End
+
+Since there are no hooks, you must explicitly trigger the state update:
+
+> "We're done for today. Please update the state files."
+
+The AI will update `.ai-memory/state.md`, `~/.ai-memory/global.md`, and append to the journal.
+
+## Limitations
+
+- No automatic session-start file loading (must be in system prompt or triggered manually)
+- No hook support for automation
+- No custom commands
+
+## What Still Works
+
+- All the file templates
+- The protocol itself (session goals, drift checks, journal)
+- Topic memory files
+- Cross-session continuity (as long as the AI reads the files)

package/templates/global.md

@@ -0,0 +1,73 @@
+# Global State — Index
+
+Last updated: YYYY-MM-DD
+
+## Preferences
+
+### Working style
+- [Communication tone — e.g. "direct, no filler, skip pleasantries"]
+- [Draft preference — e.g. "draft all external comms to me first; flag what to leave OUT"]
+- [Review step — e.g. "I review important comms with [name] before sending — always include that step"]
+
+### Technical preferences
+- [Tool/language defaults — e.g. "always TypeScript strict mode"]
+- [Commit style — e.g. "imperative mood, explain why not what"]
+- [Build/deploy habits — e.g. "never touch production before local repro"]
+
+### Team context
+<!--
+This section is where the real leverage lives. Record relationship dynamics so the AI
+handles people correctly without being re-briefed every session. Examples:
+
+- "Sarah (Design): prefers async feedback via Figma, not Slack. 24h heads-up for scope changes."
+- "Jordan (co-founder): peer, not a report. Keep informed; Jordan manages their own workload."
+- "Engineering team: mostly PST, decisions async in Notion."
+-->
+- [Name (role): key dynamic, communication preference, anything the AI should know]
+
+### Decision frameworks
+<!--
+Record how you actually think about recurring decision types. Examples:
+
+- "Pricing questions: always segment paid vs. free before drawing conclusions."
+- "Build vs. buy: default buy for non-core infra unless vendor creates lock-in risk."
+- "Vendor disputes: frame in writing first, negotiate specifics live."
+-->
+- [Decision type: your default approach or framework]
+
+## Active Projects
+
+| Project | Repo | Status | Next |
+|---------|------|--------|------|
+| Example Project | ~/repos/org/repo | Brief current status | Concrete next action |
+
+## Memory Files (load on demand)
+
+Load these from `~/.ai-memory/memory/` when the session topic matches:
+
+| File | When to load | Summary |
+|------|-------------|---------|
+| `example-topic.md` | Keywords that trigger loading | One-line summary of what's inside |
+
+## State Files (per-repo)
+
+| Location | Covers |
+|----------|--------|
+| `~/.ai-memory/state.md` | Admin work, non-repo tasks |
+| `~/repos/org/repo/.ai-memory/state.md` | What this repo is about |
+
+## Session Protocol
+
+**Start:**
+1. Read this file + the repo's `.ai-memory/state.md`
+2. Check Memory Files table — load any that match this session's topic
+3. Summarize current state, then ask: **"What's the goal for this session? What does success look like?"**
+
+**Mid-session drift check:** If work diverges from the stated goal, flag it gently and ask whether to stay the course or pivot.
+
+**End (on "stop" / "done" / "pause" / "tomorrow"):**
+1. Update this file's Active Projects row for the current repo
+2. Update the repo's `.ai-memory/state.md`
+3. Create/update topic memory files for any significant new cross-repo context
+4. Append to `~/.ai-memory/memory/journal/YYYY-MM-DD.md`
+5. Confirm: **"State saved. Say 'let's continue' next time."**

package/templates/memory-file.md

@@ -0,0 +1,18 @@
+# [Topic Name]
+
+> Load this file when: [keywords that indicate this context is relevant]
+
+## Context
+[What is this? Why does it exist as a memory file?]
+
+## Current State
+[What's the situation right now?]
+
+## Key Details
+[The actual content — decisions, strategies, data, email threads, whatever makes this worth preserving]
+
+## Next Step
+[What action is pending, if any]
+
+## History
+[Brief log of how this evolved — useful for understanding why things are the way they are]

package/templates/personal-state.md

@@ -0,0 +1,14 @@
+# [Repo Name] — Personal State
+
+Last updated: YYYY-MM-DD
+
+(This file is gitignored. It's yours — context you wouldn't want teammates reading as objective fact.)
+
+## My Current Focus
+<!-- Your personal next steps -->
+
+## Personal Context
+<!-- Working notes, opinions, relationship dynamics for this repo -->
+
+## What I'm Watching
+<!-- Open questions, things to follow up on -->

package/templates/product-state.md

@@ -0,0 +1,39 @@
+# [Repo/Area] — Product State
+
+Last updated: YYYY-MM-DD
+Source: [PM name, or "relayed by [name]", or "self — wearing PM hat"]
+
+## What We're Building
+<!-- The feature or capability in user/customer terms.
+     Not "API endpoint returns JSON" — "users can export their data as CSV from settings."
+     If this repo covers multiple features, list the active ones. -->
+
+## Why This, Why Now
+<!-- Customer problem, strategic rationale, or business driver.
+     What evidence supports this priority? (customer conversations, data, strategic bet)
+     Link to source material if it exists (Notion doc, research, Slack thread). -->
+
+## Success Criteria
+<!-- Observable outcomes in user or business terms. Not implementation milestones.
+     "Support team resolves X-type tickets without engineering help" not "function deployed."
+     Include how we'll measure it if possible. -->
+
+## Scope & Constraints
+<!-- What's in. What's explicitly out. Product decisions that constrain implementation.
+     Include the "why" — engineers will push back on constraints they don't understand.
+     Example: "No batch mode in v1 — we need to validate the single-record UX first." -->
+
+## Open Questions
+<!-- Unresolved product decisions. Engineering may add to this list during sessions
+     when they discover things that need PM input.
+     Format: Question — Who should answer — Urgency (blocking / soon / backlog) -->
+
+## Customer Signal
+<!-- What users are saying about this area. Bugs, requests, complaints, praise.
+     Include source and date so the signal can be traced back.
+     Example: "2026-02-15 — Intercom #4521 — 'We need to export by date range, not just all'" -->
+
+## Decisions Log
+<!-- Product decisions that have been made, with date and rationale. Prevents re-litigating.
+     Format: YYYY-MM-DD — Decision — Rationale
+     Example: "2026-02-10 — CSV only, no Excel — 80% of users import into Google Sheets anyway" -->

package/templates/repo-state.md

@@ -0,0 +1,18 @@
+# [Repo Name] — Project State
+
+Last updated: YYYY-MM-DD
+
+## Current Branch
+main
+
+## Current Status
+[What's the current state of play? What has been done recently? Be specific enough that a fresh session can orient immediately.]
+
+## What's Next
+[Concrete next action. Not a list of options — the one thing to pick up from.]
+
+## Blockers
+[Anything waiting on someone else, a decision, or an external dependency.]
+
+## Gotchas
+[Repo-specific things the AI should know: quirks, non-obvious patterns, traps to avoid, decisions that were made and why.]

package/templates/session-protocol-fragment.md

@@ -0,0 +1,46 @@
+# Session State Protocol
+## (Add this to your AI tool's system prompt or project instructions file)
+
+---
+
+## Session State Protocol
+
+**Memory directory:** `~/.ai-memory/` (global) and `.ai-memory/` (per-repo)
+
+**At session start (REQUIRED):**
+1. Read `~/.ai-memory/global.md` — preferences, active projects table, memory file manifest
+2. Read `.ai-memory/state.md` in the current repo — branch, progress, next steps, gotchas
+3. If `.ai-memory/product-state.md` exists, read it — product intent, success criteria, constraints. This is context from the PM/PO about *why* you're building what you're building. Keep it in mind during the session.
+4. Check the "Memory Files" table in global.md — load any files from `~/.ai-memory/memory/` whose keywords match this session's topic
+5. Summarize the current state of the project, then ask: **"What's the goal for this session? What does success look like?"**
+
+**Mid-session:**
+If the session appears to be diverging from the stated goal (new tangent, scope creep), gently flag it:
+> *"Quick check — we set out to [goal]. This feels like it's moving toward [tangent]. Want to stay the course, or deliberately pivot?"*
+If the user pivots, update the goal. This is a nudge, not a gate — the user always decides.
+
+**At session end (when user says "stop", "done", "pause", "tomorrow", "wrap up"):**
+1. Update `.ai-memory/state.md` in the current repo: what was done, what's next, blockers, gotchas
+2. Update the project's row in `~/.ai-memory/global.md` Active Projects table
+3. If significant new cross-repo context was created (patterns, strategies, decisions), create or update a file in `~/.ai-memory/memory/` and add it to the Memory Files manifest
+4. Append to `~/.ai-memory/memory/journal/YYYY-MM-DD.md`:
+
+```
+## [Repo or context] — [Brief title]
+**Why:** [The stated goal]
+**What:** [Bullet list of what was done]
+**Outcome:** [Did we hit the goal? Key deliverables]
+**On track?:** [Focused or drift? What caused drift?]
+**Lessons:** [Worth remembering cross-session]
+**Discovery:** [Optional — things learned that challenge assumptions, create new options,
+  or need PM/CTO attention. Skip if nothing notable. Include who should see this and why.]
+```
+
+5. If the session surfaced items that belong in `.ai-memory/product-state.md` (open questions for the PM, customer signal, scope discoveries), add them there.
+6. Confirm: **"State saved. Say 'let's continue' next time."**
+
+**Rules:**
+- Use the Edit tool to update files in place — don't append new sections
+- Keep `global.md` under 80 lines. Detail goes in topic files.
+- Per-repo state stays focused on that repo. Cross-repo context goes in `~/.ai-memory/memory/`
+- Do NOT use proprietary memory CLI tools for state storage. Plain markdown files only.

package/templates/strategy-state.md

@@ -0,0 +1,37 @@
+# Strategy State
+
+Last updated: YYYY-MM-DD
+
+## Current Direction
+<!-- What's the strategic thesis right now? What are we betting on and why?
+     This is the "north star" that product and engineering decisions should align to. -->
+
+## Active Research
+<!-- What's being investigated. Include the hypothesis being tested.
+     Format: Topic — Hypothesis — Status — Repo (if applicable)
+     Example: "AI extraction accuracy — Can we hit 95% on room rates? — Testing — ~/repos/research" -->
+
+## Prototype Outcomes
+<!-- What's been built, what it proved or disproved, and what to do with it.
+     This is the CTO → PM/Engineering handoff point. Be explicit about what
+     the prototype means for the product and who needs to act on it. -->
+
+| Prototype | Repo | What it proves | Status | Handoff |
+|---|---|---|---|---|
+<!-- Example row:
+| Extraction pipeline | ~/repos/research | AI extracts room rates at 95% accuracy | Complete | April: spec the support-facing UI; Nick: production-grade the pipeline |
+-->
+
+## Technology Bets
+<!-- What we're betting on, the thesis behind each bet, and what would make us reconsider.
+     Example: "Azure Container Apps for batch jobs — cheaper than Functions at scale,
+     but if cold start > 30s we'll revisit." -->
+
+## Constraints & Guardrails
+<!-- Strategic decisions that constrain product and engineering. The "we will not" list.
+     Example: "No vendor lock-in on data storage — customer must be able to export everything." -->
+
+## Patterns I'm Watching
+<!-- Cross-team observations, market signals, recurring issues. Things that aren't
+     urgent but shape where we're heading.
+     Example: "Third repo this quarter where the data model assumed 1:1 but reality is 1:many." -->

package/templates/team-state.md

@@ -0,0 +1,29 @@
+# [Repo Name] — Team State
+
+Last updated: YYYY-MM-DD
+
+## Product Context
+<!-- What is this repo building, for whom, and why? One paragraph.
+     If a product-state.md exists, summarize it here and point to it for detail.
+     Engineers: read this before starting a session. It's why your work matters. -->
+
+## Architecture & Key Decisions
+<!-- Decisions the whole team should know. Include the "why" not just the "what". -->
+
+## Conventions
+<!-- Patterns, naming, tooling choices that apply across the team. -->
+
+## Current Sprint Focus
+<!-- Team-level "what are we working on right now" -->
+
+## Signal Routing
+<!-- Where do external signals for this repo come from, and where should
+     engineering discoveries go? This helps the AI route information correctly.
+
+     Bugs & feedback: [tool — e.g. Intercom, GitHub Issues]
+     PM contact: [name — who to flag product questions to]
+     CTO/Strategy contact: [name — who to flag architectural patterns to]
+     QA process: [how testing works for this repo] -->
+
+## Shared Gotchas
+<!-- Hard-won lessons. What surprised us. What NOT to do. -->

package/uninstall.sh

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# Skip Tissue — Uninstaller
+# Removes installed hooks, commands, and settings fragments.
+# NEVER deletes your memory content (global-state.md, memory/ directory).
+#
+# Usage: bash uninstall.sh [--tool claude-code]
+
+set -euo pipefail
+
+TOOL="${1:-}"
+[[ "${1:-}" == "--tool" ]] && TOOL="${2:-}"
+[[ "${1:-}" == "--tool="* ]] && TOOL="${1#--tool=}"
+
+GREEN='\033[0;32m'; YELLOW='\033[1;33m'; RED='\033[0;31m'; RESET='\033[0m'
+log()  { echo -e "${GREEN}✓${RESET} $1"; }
+warn() { echo -e "${YELLOW}⚠${RESET}  $1"; }
+info() { echo "  $1"; }
+err()  { echo -e "${RED}✗${RESET} $1"; exit 1; }
+
+echo ""
+echo "Skip Tissue — Uninstall"
+echo ""
+warn "This will remove hooks, commands, and settings fragments."
+warn "Your memory files (global-state.md, memory/) will NOT be deleted."
+echo ""
+read -rp "Continue? [y/N] " confirm
+[[ "$confirm" =~ ^[Yy]$ ]] || { echo "Aborted."; exit 0; }
+
+# Remove hook
+HOOK="$HOME/.claude/hooks/check-global-state.sh"
+if [ -f "$HOOK" ]; then
+    rm "$HOOK"
+    log "Removed $HOOK"
+fi
+
+# Remove commands
+CMD="$HOME/.claude/commands/init-memory.md"
+if [ -f "$CMD" ]; then
+    rm "$CMD"
+    log "Removed $CMD"
+fi
+
+DOCTOR_CMD="$HOME/.claude/commands/doctor.md"
+if [ -f "$DOCTOR_CMD" ]; then
+    rm "$DOCTOR_CMD"
+    log "Removed $DOCTOR_CMD"
+fi
+
+# Remove hook from settings.json
+SETTINGS="$HOME/.claude/settings.json"
+if [ -f "$SETTINGS" ] && grep -q "check-global-state" "$SETTINGS" 2>/dev/null; then
+    python3 - "$SETTINGS" <<'PYEOF'
+import json, sys
+path = sys.argv[1]
+with open(path) as f:
+    settings = json.load(f)
+hooks = settings.get("hooks", {})
+session_start = hooks.get("SessionStart", [])
+hooks["SessionStart"] = [h for h in session_start if "check-global-state" not in h.get("command", "")]
+if not hooks["SessionStart"]:
+    del hooks["SessionStart"]
+if not hooks:
+    del settings["hooks"]
+with open(path, "w") as f:
+    json.dump(settings, f, indent=2)
+    f.write("\n")
+PYEOF
+    log "Removed hook from $SETTINGS"
+fi
+
+# Remove installed kit copy
+KIT_DEST="$HOME/.claude/skip-tissue"
+if [ -d "$KIT_DEST" ]; then
+    rm -rf "$KIT_DEST"
+    log "Removed $KIT_DEST"
+fi
+
+echo ""
+log "Uninstall complete."
+echo ""
+info "Your memory files are preserved:"
+info "  ~/.claude/global-state.md"
+info "  ~/.claude/memory/"
+info ""
+info "To reinstall: curl -fsSL https://raw.githubusercontent.com/leizerowicz/skip-tissue/main/install.sh | bash"