meridian-dev 1.1.0

package/specializations/claude-code/commands/init-memory.md

@@ -0,0 +1,127 @@
+---
+description: Initialize the Skip Tissue for the current repo. Creates .claude/team-state.md (tracked in git) and .claude/personal-state.md (gitignored), ensures correct .gitignore entries, appends session protocol to CLAUDE.md, and registers the repo in the global index. Safe to run multiple times (idempotent).
+---
+
+# Initialize Memory System for Current Repo
+
+Run these steps in order. Skip any step that's already done (this command is idempotent).
+
+## Step 1: Detect Context
+
+- Determine the current working directory
+- Check if it's a git repo (`ls .git` or `git rev-parse --show-toplevel`)
+- Read `~/.claude/global-state.md` to check if this repo is already registered
+
+## Step 2: Create state files (if missing)
+
+This repo uses TWO state files with different visibility:
+
+**`.claude/team-state.md`** — committed to git (shared team context)
+
+If `.claude/team-state.md` does not exist, create it:
+
+```markdown
+# [Repo Name] — Team State
+
+Last updated: [today's date]
+
+## 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" -->
+
+## Shared Gotchas
+<!-- Hard-won lessons. What surprised us. What NOT to do. -->
+```
+
+**`.claude/personal-state.md`** — gitignored (your personal context)
+
+If `.claude/personal-state.md` does not exist, create it:
+
+```markdown
+# [Repo Name] — Personal State
+
+Last updated: [today's date]
+
+(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 -->
+```
+
+## Step 3: Fix `.gitignore`
+
+Check `.gitignore`. Ensure these lines are present:
+
+```
+.claude/personal-state.md
+.claude/settings.local.json
+.claude/memory.db
+```
+
+**Do NOT add `.claude/` as a whole directory.** That breaks skills and commands. Only add the specific files above. Note that `team-state.md` is intentionally NOT gitignored — it is meant to be committed and shared with your team.
+
+If any of those lines are missing, append them. If `.claude/` (as a directory) is already in `.gitignore`, remove it and replace with the three file-level entries above.
+
+## Step 4: Append Session Protocol to CLAUDE.md
+
+Read the repo's `CLAUDE.md`. If it does NOT already contain "Session State Protocol", append this:
+
+```markdown
+
+## Session State Protocol
+
+**At session start (REQUIRED):**
+1. Read `~/.claude/global-state.md` — preferences, active projects, memory file manifest
+2. Read `.claude/team-state.md` in this repo — shared team context: architecture decisions, conventions, sprint focus, gotchas
+3. Read `.claude/personal-state.md` in this repo — your personal context: current focus, working notes, opinions
+4. Check the Memory Files table in global-state.md — load any `~/.claude/memory/` files relevant to this session's topic
+
+**At session end (when user says stop/done/pause/tomorrow):**
+1. Update `.claude/team-state.md` with shared context: architecture decisions, conventions, gotchas the team should know
+2. Update `.claude/personal-state.md` with personal context: your next steps, working notes, opinions
+3. Update the project's row in `~/.claude/global-state.md` Active Projects table
+4. If significant new cross-repo context was created (patterns, strategies, decisions), create or update a file in `~/.claude/memory/` and add it to the Memory Files manifest in global-state.md
+
+**Do NOT use ruvector/claude-flow memory CLI for state storage.** Use plain markdown files only.
+```
+
+If `CLAUDE.md` doesn't exist, create a minimal one with the repo name as a heading and the block above.
+
+## Step 5: Register in Global Index
+
+Read `~/.claude/global-state.md`. If the current repo is NOT in the Active Projects table, add a row:
+
+```
+| [Project Name] | [full repo path] | New — just initialized | TBD |
+```
+
+Add the repo's state files to the State Files table if missing:
+
+```
+| `[full path]/.claude/team-state.md` | Shared team context for this repo |
+| `[full path]/.claude/personal-state.md` | Personal context for this repo (gitignored) |
+```
+
+## Step 6: Report
+
+Tell the user:
+- `.claude/team-state.md` — created or already existed (committed to git, shared with team)
+- `.claude/personal-state.md` — created or already existed (gitignored, personal only)
+- `.gitignore` — updated or already correct
+- `CLAUDE.md` — protocol appended or already present
+- `global-state.md` — repo registered or already listed
+
+**If they haven't set up team context yet**, mention:
+"Run `/init-team` to set up team-level context sharing — shared journals, weekly digests
+(Slack + Notion), and product state for your PM."

package/specializations/claude-code/commands/init-team.md

@@ -0,0 +1,335 @@
+---
+description: Set up Meridian team context for your organization. Interactive walkthrough that creates a team context repo, configures Slack digests, sets up Notion integration, and initializes product-state.md for a pilot repo. Run once per team.
+---
+
+# Initialize Team Context (Meridian)
+
+Interactive setup for team-level context sharing. Walk the user through each step,
+asking questions as needed. Skip steps that are already done (idempotent).
+
+## Prerequisites Check
+
+Before starting, verify:
+1. Skip Tissue is installed (`~/.claude/skip-tissue/` exists)
+2. User has `gh` CLI authenticated (`gh auth status`)
+3. User is in a git repo within an organization (or can specify one)
+4. Ask: **"Which GitHub org will host the team context repo?"** (e.g., `HopSkipInc`)
+
+If any prerequisite fails, tell the user what's needed and stop.
+
+## Step 1: Team Context Repo
+
+This repo holds shared journals, strategy state, digest archives, and the GitHub
+Action that generates digests.
+
+Ask: **"Do you already have a team context repo for shared journals and digests? If so, what's the repo name? If not, I'll help you create one."**
+
+### If creating new:
+
+Ask: **"What should the repo be called?"** Suggest: `<org>/engineering-context`
+
+Guide the user:
+```
+gh repo create <org>/<repo-name> --private --description "Team decision trail — journals, digests, strategy (powered by Meridian)"
+```
+
+Then clone it and create the initial structure:
+```
+<repo>/
+  README.md              # Brief explanation of what this repo is
+  strategy-state.md      # CTO strategy (from templates/strategy-state.md)
+  journals/              # One subdirectory per team member
+    <username>/          # Journal files sync here from each person's local
+  digests/               # Archive of generated digests
+  .github/workflows/     # Digest generation (added in Step 2)
+```
+
+Create `README.md` with:
+```markdown
+# Team Context
+
+Shared decision trail for [team name]. Powered by [Meridian](https://github.com/leizerowicz/skip-tissue).
+
+## What's here
+
+- `strategy-state.md` — Strategic direction, research, prototypes, technology bets
+- `journals/` — AI session journals from each team member (auto-synced)
+- `digests/` — Weekly digest archives
+- `.github/workflows/` — Automated digest generation
+
+## How it works
+
+Team members use Skip Tissue in their daily AI-assisted development sessions.
+Journals capture what was done, what was decided, what was discovered, and what drifted.
+Weekly digests aggregate this into views for engineering, product, and strategy.
+```
+
+Create `strategy-state.md` from the strategy-state template in this repo's
+`templates/strategy-state.md`. Fill in today's date. Ask the user to provide
+a brief summary of current strategic direction (or leave placeholder comments).
+
+Create the `journals/` directory with a `.gitkeep` file.
+Create the `digests/` directory with a `.gitkeep` file.
+
+Commit and push the initial structure.
+
+### If existing:
+
+Clone or pull the repo. Verify it has `journals/` and `digests/` directories.
+Create them if missing.
+
+Store the team context repo path for later steps. Record it in `~/.claude/global-state.md`
+in the Memory Files table:
+
+```
+| `meridian-team-context.md` | team context, journals, digests, meridian | Team context repo location and configuration |
+```
+
+Create `~/.claude/memory/meridian-team-context.md` with:
+```markdown
+# Meridian Team Context
+
+> Load this file when: team context, journals, digests, meridian, init-team
+
+## Team Context Repo
+- Org: <org>
+- Repo: <org>/<repo-name>
+- Local path: <path>
+
+## Integrations Configured
+- Slack webhook: [yes/no — URL stored in repo secret]
+- Notion: [yes/no — page ID]
+
+## Team Members
+- <list of usernames with journal directories>
+```
+
+## Step 2: Slack Integration
+
+Ask: **"Do you want weekly digests posted to Slack? You'll need a Slack Incoming Webhook URL. If you have one, paste it. If not, I can walk you through creating one."**
+
+### If they need help creating a webhook:
+1. Go to https://api.slack.com/apps → Create New App → From Scratch
+2. Name it "Meridian Digests" (or team preference), select workspace
+3. Features → Incoming Webhooks → Activate
+4. Add New Webhook to Workspace → Select channel (suggest `#engineering`)
+5. Copy the webhook URL
+
+### Once they have the URL:
+
+Store it as a GitHub repo secret (NOT in plain text):
+```
+gh secret set SLACK_WEBHOOK_URL --repo <org>/<team-context-repo> --body "<webhook-url>"
+```
+
+Ask: **"Which Slack channel(s) should receive digests?"**
+Suggest defaults:
+- Engineering digest → `#engineering`
+- PM digest → `#product` (or the same channel if team is small)
+- Strategy digest → `#leadership` (or skip if CTO just reads the Notion page)
+
+Record the channel configuration in `meridian-team-context.md`.
+
+### Create the GitHub Action:
+
+Create `.github/workflows/weekly-digest.yml` in the team context repo:
+
+```yaml
+name: Weekly Digest
+
+on:
+  schedule:
+    - cron: '0 10 * * 1'  # Monday 10:00 UTC (adjust for timezone)
+  workflow_dispatch:  # Manual trigger for testing
+
+jobs:
+  digest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Skip Tissue
+        run: |
+          curl -fsSL https://raw.githubusercontent.com/leizerowicz/skip-tissue/main/install.sh | bash
+
+      - name: Generate engineering digest
+        run: |
+          ~/.claude/skip-tissue/journal-summary.sh \
+            --team journals \
+            --last-week \
+            --format markdown \
+            > digests/engineering-$(date +%Y-%m-%d).md
+
+      - name: Post to Slack
+        if: env.SLACK_WEBHOOK_URL != ''
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+        run: |
+          DIGEST=$(cat digests/engineering-$(date +%Y-%m-%d).md | head -c 3000)
+          curl -X POST "$SLACK_WEBHOOK_URL" \
+            -H 'Content-type: application/json' \
+            -d "$(jq -n --arg text "$DIGEST" '{text: $text}')"
+
+      - name: Archive digest
+        run: |
+          git config user.name "Meridian Bot"
+          git config user.email "meridian-bot@users.noreply.github.com"
+          git add digests/
+          git diff --cached --quiet || git commit -m "Weekly digest $(date +%Y-%m-%d)"
+          git push
+```
+
+Tell the user: **"You can test the digest manually: go to the Actions tab in the team context repo and run the 'Weekly Digest' workflow."**
+
+## Step 3: Notion Integration
+
+Ask: **"Do you want digests and product context visible in Notion? This creates a shared Notion page your PM and team can browse."**
+
+### If yes:
+
+Ask: **"What Notion workspace should I create the Meridian pages in? I can search for existing pages or create a new top-level page."**
+
+Use the Notion MCP tools to:
+
+1. **Create a top-level page**: "Meridian — [Team Name]"
+   - Use `mcp__notion__notion-create-pages` or the Claude.ai Notion tools
+
+2. **Create child pages**:
+   - "Weekly Digests" — will hold one child page per week
+   - "Product State" — browseable product intent (mirrors product-state.md files)
+   - "Decisions Log" — searchable history of product decisions
+   - "Strategy" — mirrors strategy-state.md
+
+3. For now, note the page IDs. Full Notion sync (automated posting of digests to
+   Notion pages) will be added as a GitHub Action step later. For the dogfood phase,
+   digests can be manually pasted or the CTO can update Notion from their session.
+
+Record the Notion page IDs in `meridian-team-context.md`.
+
+Tell the user: **"Notion pages created. For now, digests will post to Slack automatically. Notion gets updated when you or a team member copies the digest over, or we can automate that next."**
+
+## Step 4: Product State for Pilot Repo
+
+Ask: **"Which repo should we set up product-state.md for first? I'll create the PM intent layer so engineering sessions have product context."**
+
+Navigate to that repo (or confirm we're already in it).
+
+Create `.claude/product-state.md` using the template from `templates/product-state.md`.
+
+Walk through filling it in interactively:
+
+1. Ask: **"Who's the PM for this repo?"** → record in team-state.md Signal Routing
+2. Ask: **"In one or two sentences, what is this repo building and for whom?"** → fill "What We're Building"
+3. Ask: **"Why is this the priority right now?"** → fill "Why This, Why Now"
+4. Ask: **"How will you know it's working? What does success look like in user terms?"** → fill "Success Criteria"
+5. Ask: **"Any scope constraints or product decisions that engineering should know?"** → fill "Scope & Constraints"
+6. Ask: **"Any open questions that haven't been decided yet?"** → fill "Open Questions"
+
+If the user doesn't know answers to some questions, leave the placeholder comments.
+Those fields will get filled by the PM in a future session.
+
+## Step 5: Update Team State
+
+If `.claude/team-state.md` exists in the pilot repo, update the Signal Routing section:
+
+```markdown
+## Signal Routing
+Bugs & feedback: [answer from user or "TBD"]
+PM contact: [PM name from Step 4]
+CTO/Strategy contact: [user's name or "TBD"]
+QA process: [answer from user or "TBD"]
+```
+
+If it doesn't exist, create it from `templates/team-state.md` and fill in what we know.
+
+## Step 6: Journal Sync Configuration
+
+Each team member's journals need to flow to the team context repo. Set up the sync
+for the current user.
+
+Create a journal sync script at `~/.claude/hooks/sync-team-journal.sh`:
+
+```bash
+#!/usr/bin/env bash
+# Meridian — Sync journals to team context repo
+# Called by session-end hook after local journal is updated
+
+set -euo pipefail
+
+TEAM_REPO="<path-to-team-context-repo>"
+USER_DIR="$TEAM_REPO/journals/$(whoami)"
+
+# Only sync if team repo exists and has journals dir
+[ -d "$TEAM_REPO/journals" ] || exit 0
+
+mkdir -p "$USER_DIR"
+
+# Copy journal files (not personal state)
+JOURNAL_DIR=""
+if [ -d "$HOME/.claude/memory/journal" ]; then
+    JOURNAL_DIR="$HOME/.claude/memory/journal"
+elif [ -d "$HOME/.ai-memory/memory/journal" ]; then
+    JOURNAL_DIR="$HOME/.ai-memory/memory/journal"
+fi
+
+[ -z "$JOURNAL_DIR" ] && exit 0
+
+# Sync only .md files from journal dir
+rsync -a --include='*.md' --exclude='*' "$JOURNAL_DIR/" "$USER_DIR/"
+
+# Commit and push if there are changes
+cd "$TEAM_REPO"
+git add "journals/$(whoami)/" 2>/dev/null || true
+if ! git diff --cached --quiet 2>/dev/null; then
+    git commit -m "Journal sync: $(whoami) $(date +%Y-%m-%d)" --quiet
+    git push --quiet 2>/dev/null || true
+fi
+```
+
+Make it executable. Tell the user to add this to their session-end hook in
+`~/.claude/settings.json` (or integrate with their existing backup hook).
+
+Provide the exact settings.json snippet to add.
+
+## Step 7: Onboarding Instructions
+
+Generate a message the user can send to their team. Ask: **"What's the best way to share setup instructions with your team? Slack message? Notion page?"**
+
+Draft the onboarding message:
+
+```
+Hey team — I've set up Meridian for our engineering context.
+
+**What it does**: Captures the decisions, discoveries, and context from your AI-assisted
+sessions and generates weekly digests so everyone stays oriented.
+
+**What you need to do**:
+1. Install Skip Tissue (30 seconds):
+   Open Claude Code and paste:
+   ```
+   curl -fsSL https://raw.githubusercontent.com/leizerowicz/skip-tissue/main/install.sh | bash
+   ```
+2. In any repo you work in, run `/init-memory` to set up context tracking
+3. That's it. Work normally. Claude will capture context at the end of each session.
+
+**What you'll see**:
+- Monday digest in #[channel] showing what shipped, what drifted, and what was discovered
+- Product context in your sessions (so your AI knows *why* you're building what you're building)
+
+Questions? Ask [user's name].
+```
+
+## Step 8: Report
+
+Summarize everything that was set up:
+
+- Team context repo: `<org>/<repo>` — created/configured
+- Slack: webhook configured, posting to `#<channel>` on Mondays
+- Notion: pages created at [page link] (or skipped)
+- Product state: initialized in `<pilot-repo>` with PM = `<name>`
+- Journal sync: configured for current user
+- Onboarding: message drafted for team
+
+Tell the user: **"Team context is set up. Send the onboarding message to your team,
+then run the GitHub Action manually to test the first digest. Once journals start
+flowing, you'll see the first real digest next Monday."**

package/specializations/claude-code/commands/journal.md

@@ -0,0 +1,66 @@
+---
+description: Generate a journal summary — weekly digest, drift detection, and recurring lessons from AI session journals.
+---
+
+# Skip Tissue — Journal Summary
+
+Aggregate AI session journal entries into a weekly digest with drift detection and recurring lesson extraction.
+
+## Step 1: Run journal-summary.sh
+
+Look for `~/.claude/skip-tissue/journal-summary.sh`. If found, run it based on what the user asked:
+
+```bash
+# This week (default)
+bash ~/.claude/skip-tissue/journal-summary.sh
+
+# Last week
+bash ~/.claude/skip-tissue/journal-summary.sh --last-week
+
+# Specific date range
+bash ~/.claude/skip-tissue/journal-summary.sh --from 2026-02-01 --to 2026-02-28
+
+# All history as Markdown (good for Notion/GitHub)
+bash ~/.claude/skip-tissue/journal-summary.sh --all --format markdown
+
+# Team aggregate (each subdir is a contributor's journal dir)
+bash ~/.claude/skip-tissue/journal-summary.sh --team ~/team-journals
+
+# Custom journal directory
+bash ~/.claude/skip-tissue/journal-summary.sh --dir ~/.ai-memory/memory/journal
+```
+
+## Step 2: If journal-summary.sh is not installed
+
+Run setup.sh with `--update` to install it:
+```bash
+bash ~/repos/greg/skip-tissue/setup.sh --tool claude-code --update
+```
+
+Or install manually:
+```bash
+cp ~/repos/greg/skip-tissue/journal-summary.sh ~/.claude/skip-tissue/journal-summary.sh
+chmod +x ~/.claude/skip-tissue/journal-summary.sh
+```
+
+## Step 3: Interpret results
+
+The summary surfaces four key sections:
+
+- **Sessions by Repo** — Every session in the period, grouped by repo. ⚠ marks drifted sessions.
+- **Drift Log** — Sessions where "On track?" indicated scope creep or goal drift. Review these to identify recurring blockers.
+- **Recurring Lessons** — Lessons that appeared in 2+ sessions. These are strong candidates to add to `CLAUDE.md` or `global-state.md` so the AI learns from them.
+- **All Lessons** — Full lesson archive for the period, with ♻ markers on recurring ones.
+
+## Options quick reference
+
+```
+--dir <path>        Journal directory (auto-detects ~/.claude or ~/.ai-memory)
+--team <path>       Team mode: each subdirectory is a contributor's journal dir
+--week              This week Mon–Sun (default)
+--last-week         Last week Mon–Sun
+--from <YYYY-MM-DD> Start date
+--to   <YYYY-MM-DD> End date (default: today)
+--all               All available journal files
+--format markdown   Output as Markdown instead of plain text
+```

package/specializations/claude-code/hooks/check-global-state.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Skip Tissue — Anti-Drift Hook for Claude Code
+# Runs on SessionStart. Warns when a repo's .claude/state.md is newer than
+# ~/.claude/global-state.md, indicating the global Active Projects table
+# may be stale for this repo.
+#
+# Install: copy to ~/.claude/hooks/check-global-state.sh
+# Register: add to ~/.claude/settings.json (see settings.json in this directory)
+
+set -euo pipefail
+
+GLOBAL_STATE="$HOME/.claude/global-state.md"
+# Try team-state.md first (new split convention), fall back to state.md
+REPO_STATE=".claude/team-state.md"
+[ -f "$REPO_STATE" ] || REPO_STATE=".claude/state.md"
+
+# Extract "Last updated: YYYY-MM-DD" from a file
+get_date() {
+    grep -m1 '^Last updated:' "$1" 2>/dev/null | sed 's/^Last updated: *//; s/\r//' || echo ""
+}
+
+# --- Check current repo ---
+if [ -f "$REPO_STATE" ]; then
+    REPO_DATE=$(get_date "$REPO_STATE")
+    GLOBAL_DATE=$(get_date "$GLOBAL_STATE")
+
+    if [ -n "$REPO_DATE" ] && [ -n "$GLOBAL_DATE" ]; then
+        if [[ "$REPO_DATE" > "$GLOBAL_DATE" ]]; then
+            REPO_NAME=$(basename "$(git -C . rev-parse --show-toplevel 2>/dev/null || pwd)")
+            STATE_FILE=$(basename "$REPO_STATE")
+            echo "⚠️  STALE GLOBAL STATE: ${REPO_NAME}/.claude/${STATE_FILE} was updated ${REPO_DATE} but ~/.claude/global-state.md was last updated ${GLOBAL_DATE}."
+            echo "ACTION REQUIRED: Update the Active Projects row for '${REPO_NAME}' in ~/.claude/global-state.md before proceeding."
+        fi
+    fi
+fi
+
+# --- Scan all repos for broader staleness ---
+# Scan roots: colon-separated list of directories to search for repo state files.
+# Override by setting AI_MEMORY_SCAN_ROOTS in your environment (colon-separated).
+# Default: $HOME/repos:$HOME/code:$HOME/dev:$HOME/projects
+IFS=: read -ra SCAN_ROOT_ARRAY <<< "${AI_MEMORY_SCAN_ROOTS:-$HOME/repos:$HOME/code:$HOME/dev:$HOME/projects}"
+
+STALE_REPOS=()
+GLOBAL_DATE=$(get_date "$GLOBAL_STATE")
+
+if [ -n "$GLOBAL_DATE" ]; then
+    for root in "${SCAN_ROOT_ARRAY[@]}"; do
+        [ -d "$root" ] || continue
+        while IFS= read -r state_file; do
+            FILE_DATE=$(get_date "$state_file")
+            if [ -n "$FILE_DATE" ] && [[ "$FILE_DATE" > "$GLOBAL_DATE" ]]; then
+                rel="${state_file#$HOME/}"
+                repo_name="${rel%/.claude/team-state.md}"
+                repo_name="${repo_name%/.claude/state.md}"
+                STALE_REPOS+=("$repo_name ($FILE_DATE)")
+            fi
+        done < <(find "$root" \( -path '*/.claude/state.md' -o -path '*/.claude/team-state.md' \) -not -path '*/node_modules/*' 2>/dev/null)
+    done
+
+    if [ ${#STALE_REPOS[@]} -gt 0 ]; then
+        echo ""
+        echo "📋 Other repos with state newer than global-state.md (${GLOBAL_DATE}):"
+        for r in "${STALE_REPOS[@]}"; do
+            echo "   - $r"
+        done
+        echo "Consider updating their Active Projects rows when convenient."
+    fi
+fi

package/specializations/claude-code/settings.json

@@ -0,0 +1,10 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "type": "command",
+        "command": "bash ~/.claude/hooks/check-global-state.sh"
+      }
+    ]
+  }
+}