@woopsy/ai-agent-skills 1.0.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@woopsy/ai-agent-skills",
+  "version": "1.0.0",
+  "description": "Multi-function AI agent skills — SecondaryBrain vault protocol, CI/CD pipeline, auto-installer for all agents",
+  "bin": {
+    "ai-agent-skills": "bin/ai-agent-skills.js"
+  },
+  "scripts": {
+    "push": "node scripts/push.js",
+    "lint": "echo 'no linter configured yet' && exit 0",
+    "typecheck": "echo 'no typecheck configured yet' && exit 0",
+    "test": "echo 'no tests configured yet' && exit 0",
+    "setup": "node scripts/install.js"
+  },
+  "files": [
+    "skills/",
+    "scripts/",
+    "bin/",
+    "SKILL.md",
+    "install.ps1",
+    "install.sh",
+    ".claude-plugin/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "keywords": [
+    "secondary-brain",
+    "obsidian",
+    "vault",
+    "cicd",
+    "agents",
+    "skills",
+    "claude-code",
+    "opencode",
+    "cursor",
+    "codex",
+    "gemini"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,51 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const ROOT = path.resolve(__dirname, '..');
+
+function run(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', cwd: ROOT }).trim();
+  } catch { return ''; }
+}
+
+async function main() {
+  console.log('============================================');
+  console.log('   AI Agent Skills — Installer');
+  console.log('============================================\n');
+
+  // Detect platform
+  const isWin = process.platform === 'win32';
+  const isWSL = run('uname -r').toLowerCase().includes('microsoft');
+
+  if (isWSL && isWin) {
+    // Running on Windows but WSL detected — use PowerShell
+    console.log('→ WSL detected. Using PowerShell installer...\n');
+    const psScript = path.resolve(ROOT, 'install.ps1');
+    if (fs.existsSync(psScript)) {
+      run(`powershell.exe -ExecutionPolicy Bypass -File "${psScript}"`);
+      return;
+    }
+  }
+
+  if (isWin) {
+    const psScript = path.resolve(ROOT, 'install.ps1');
+    if (fs.existsSync(psScript)) {
+      run(`powershell.exe -ExecutionPolicy Bypass -File "${psScript}"`);
+      return;
+    }
+  }
+
+  const shScript = path.resolve(ROOT, 'install.sh');
+  if (fs.existsSync(shScript)) {
+    run(`chmod +x "${shScript}"`);
+    run(`bash "${shScript}"`);
+    return;
+  }
+
+  console.log('No installer found for this platform.');
+  console.log('See reference/platform-adapters.md for manual install.');
+}
+
+main().catch(console.error);

package/scripts/push.js

@@ -0,0 +1,193 @@
+const { execSync } = require('child_process');
+const readline = require('readline');
+const path = require('path');
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+const ask = (q) => new Promise((r) => rl.question(q, r));
+const run = (cmd, opts = {}) => {
+  try {
+    const out = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], ...opts });
+    return { ok: true, out: out.trim() };
+  } catch (e) {
+    return { ok: false, out: (e.stderr || e.message || '').trim() };
+  }
+};
+const npmScriptExists = (name) => {
+  const { ok, out } = run(`npm run ${name} --dry-run 2>&1 || true`);
+  return ok && !out.includes('missing script');
+};
+
+async function main() {
+  // --- 1. OS detection ---
+  const isWSL = run('uname -r').out.toLowerCase().includes('microsoft') ||
+                process.env.WSLENV !== undefined;
+  console.log(isWSL ? '🌐 Environment: WSL' : '🖥  Environment: Windows');
+
+  // --- 2. Check dev branch exists ---
+  console.log('\n📋 Checking branches...');
+  const branches = run('git branch -a').out;
+  const hasDev = /\bdev\b/.test(branches);
+  if (!hasDev) {
+    console.log('  ✗ No "dev" branch found. Create it: git checkout -b dev');
+    process.exit(1);
+  }
+  console.log('  ✓ dev branch exists');
+
+  // --- 3. Check current branch ---
+  const { ok: brOk, out: branch } = run('git rev-parse --abbrev-ref HEAD');
+  if (!brOk) { console.log('  ✗ Not a git repository'); process.exit(1); }
+  console.log(`  Current branch: ${branch}`);
+
+  if (branch === 'prod' || branch === 'main') {
+    const ans = await ask('  ⛔ PUSHING TO PROD IS BLOCKED. Switch to dev? [Y/n] ');
+    if (ans.toLowerCase() === 'n' || ans.toLowerCase() === 'no') {
+      console.log('  Aborted.');
+      process.exit(1);
+    }
+    // Stash if dirty then switch
+    const status = run('git status --porcelain');
+    if (status.out) {
+      run('git stash push -m "auto-stash before dev switch"');
+      run('git switch dev');
+      console.log('  ✓ Stashed changes, switched to dev');
+    } else {
+      run('git switch dev');
+      console.log('  ✓ Switched to dev');
+    }
+  } else if (branch !== 'dev') {
+    const ans = await ask(`  ⚠️  On "${branch}", not dev. Switch to dev? [Y/n] `);
+    if (ans.toLowerCase() !== 'n' && ans.toLowerCase() !== 'no') {
+      const st = run('git status --porcelain');
+      if (st.out) {
+        run('git stash push -m "auto-stash before dev switch"');
+        run('git switch dev');
+        console.log('  ✓ Stashed changes, switched to dev');
+      } else {
+        run('git switch dev');
+        console.log('  ✓ Switched to dev');
+      }
+    }
+  } else {
+    console.log('  ✓ On dev branch');
+  }
+
+  // Re-read branch after potential switch
+  const finalBranch = run('git rev-parse --abbrev-ref HEAD').out;
+
+  // --- 4. Check remote ---
+  console.log('\n📡 Checking remote...');
+  const { ok: hasRemote, out: remoteUrl } = run('git remote get-url origin');
+  if (!hasRemote) {
+    console.log('  ⚠️  No remote repository configured.');
+    console.log('  Set one up: git remote add origin <url>');
+    process.exit(1);
+  }
+  const displayUrl = remoteUrl.replace(/^git@(.+):(.+)$/, 'https://$1/$2');
+  console.log(`  → Push target: ${displayUrl}`);
+
+  // --- 5. CI Checks ---
+  console.log('\n🔬 Running pre-push checks...');
+  let allPassed = true;
+
+  const checks = [
+    { name: 'Lint', script: 'lint' },
+    { name: 'Type Check', script: 'typecheck' },
+    { name: 'Test', script: 'test' },
+  ];
+
+  for (const check of checks) {
+    if (npmScriptExists(check.script)) {
+      process.stdout.write(`  ${check.name}...`);
+      const result = run(`npm run ${check.script}`);
+      if (result.ok) {
+        console.log(' ✓');
+      } else {
+        console.log(' ✗');
+        console.log(`    ${result.out.split('\n').slice(0, 5).join('\n    ')}`);
+        allPassed = false;
+      }
+    } else {
+      console.log(`  ${check.name}... ⏭  (not configured)`);
+    }
+  }
+
+  if (!allPassed) {
+    console.log('\n  ✗ Pre-push checks failed. Fix errors before pushing.');
+    process.exit(1);
+  }
+  console.log('  ✓ All checks passed');
+
+  // --- 6. Check for changes ---
+  console.log('\n📝 Checking working tree...');
+  const statusOut = run('git status --porcelain').out;
+  let forceEmpty = false;
+
+  if (!statusOut) {
+    const ans = await ask('  ℹ️  No changes to commit. Force empty commit? [y/N] ');
+    if (ans.toLowerCase() !== 'y' && ans.toLowerCase() !== 'yes') {
+      console.log('  Aborted.');
+      process.exit(1);
+    }
+    forceEmpty = true;
+  } else {
+    console.log(`  ${statusOut.split('\n').length} file(s) changed`);
+  }
+
+  // --- 7. Changelog prompt ---
+  console.log('\n📖 SecondaryBrain changelog check...');
+  const vaultHint = process.env.VAULT_PATH || '';
+  if (vaultHint) {
+    console.log(`  Vault: ${vaultHint}`);
+  }
+  const changelogAns = await ask('  Did you update the changelog (_Changelog/YYYY-MM-DD.md)? [y/N] ');
+  if (changelogAns.toLowerCase() !== 'y' && changelogAns.toLowerCase() !== 'yes') {
+    console.log('  ✗ Please update the changelog first.');
+    console.log('    Document what changed and why in _Changelog/YYYY-MM-DD.md');
+    process.exit(1);
+  }
+  console.log('  ✓ Changelog confirmed');
+
+  // --- 8. Commit message ---
+  const msg = await ask('\n✏️  Commit message: ');
+  if (!msg.trim()) {
+    console.log('  ✗ Commit message required');
+    process.exit(1);
+  }
+
+  // --- 9. Commit and push ---
+  console.log('\n🚀 Pushing...');
+  run('git add -A');
+
+  const commitCmd = forceEmpty
+    ? `git commit --allow-empty -m "${msg.replace(/"/g, '\\"')}"`
+    : `git commit -m "${msg.replace(/"/g, '\\"')}"`;
+  const commitResult = run(commitCmd);
+
+  if (!commitResult.ok) {
+    console.log(`  ✗ Commit failed:\n    ${commitResult.out}`);
+    process.exit(1);
+  }
+  console.log('  ✓ Committed');
+
+  const pushResult = run(`git push origin ${finalBranch}`);
+  if (pushResult.ok) {
+    console.log(`  ✓ Pushed to ${finalBranch}`);
+    console.log(`  → ${displayUrl}`);
+  } else {
+    console.log(`  ✗ Push failed:\n    ${pushResult.out}`);
+    console.log('  Check:');
+    console.log('    - Remote URL correct?');
+    console.log('    - You have push access?');
+    console.log('    - Branch protection rules?');
+    process.exit(1);
+  }
+
+  rl.close();
+}
+
+main().catch((e) => {
+  console.error('Unexpected error:', e.message);
+  process.exit(1);
+  rl.close();
+});

package/skills/cicd/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: cicd
+description: "CI/CD pipeline: ensures vault + skills installed, runs quality gates, enforces branch rules, offers push flow with changelog gate."
+argument-hint: "[pipeline|setup|push|workflows]"
+---
+
+# CI/CD Pipeline — `/woopsy cdci`
+
+Full automation pipeline. Ensures infrastructure is in place before any code goes out.
+
+## `pipeline` — Full Pipeline (default for /woopsy cdci)
+
+Execute in order:
+
+### Step 1: Update Dependencies
+
+```bash
+cd skills/obsidian && git pull --ff-only 2>/dev/null
+cd skills/graphify && git pull --ff-only 2>/dev/null
+```
+
+If either is missing, clone:
+```bash
+git clone --depth 1 https://github.com/kepano/obsidian-skills.git skills/obsidian
+git clone --depth 1 https://github.com/Graphify-Labs/graphify.git skills/graphify
+```
+
+### Step 2: Ensure Vault Connected
+
+Check `brain-config.json` exists at `skills/secondary-brain/brain-config.json`.
+
+If missing → run `install.ps1` (Windows) or `install.sh` (WSL/Linux) to:
+- Detect or scaffold SecondaryBrain vault
+- Install all skills to current agent
+
+Report vault status.
+
+### Step 3: Install Skills to Current Agent
+
+Ensure the following are registered with the current agent:
+- `secondary-brain` (this skill set)
+- `obsidian-skills` (obsidian-markdown, obsidian-bases, json-canvas, obsidian-cli, defuddle)
+- `graphify` (knowledge graph)
+
+For each missing skill, copy the SKILL.md directory into the agent's skill directory and register it.
+
+### Step 4: Branch Check
+
+```
+git branch -a | grep dev
+  → if missing: "Create dev branch first: git checkout -b dev" → abort
+
+git rev-parse --abbrev-ref HEAD
+  → if "prod"/"main": BLOCK → "Switch to dev? [Y/n]"
+  → if "dev": continue
+  → if other: warn → "Continue on current branch? [Y/n]"
+```
+
+### Step 5: Remote Check
+
+```
+git remote get-url origin
+  → if missing: "No remote configured. Set one up." → abort
+  → show target URL
+```
+
+### Step 6: Quality Gates
+
+```
+npm run lint          (skip if not configured)
+npm run typecheck     (skip if not configured)
+npm test              (skip if not configured)
+  → any failure: block → "Fix errors before pushing"
+```
+
+### Step 7: Changelog Gate
+
+```
+Ask: "Did you update _Changelog/YYYY-MM-DD.md?"
+  → No: "Update it first. Document what changed and why." → abort
+  → Yes: continue
+```
+
+### Step 8: Push Flow
+
+```
+Check git status --porcelain
+  → clean: "Force empty commit? [y/N]"
+  → dirty: show changed file count
+
+Prompt: "Commit message: "
+  → empty: abort
+  → filled: git add -A && git commit -m "<msg>" && git push origin <branch>
+
+On success: "✓ Pushed to <branch> → <remote-url>"
+On fail: show error with troubleshooting steps
+```
+
+## `setup` — Configure CI/CD
+
+To enable the full pipeline:
+
+1. Set up GitHub repository with `dev` as default branch
+2. Add repository secrets in GitHub
+3. Push the `.github/workflows/` files
+4. Create branch protection rules on `prod`
+
+## `push` — Manual Push
+
+Same as steps 4-8 of the pipeline above. Skips dependency check, vault check, and skill install. Use when you already know everything is set up.
+
+## `workflows` — GitHub Actions Anatomy
+
+**dev.yml** (runs on push to `dev`):
+- Lint
+- Type check
+- Test
+
+**prod.yml** (runs on push/PR to `prod`/`main`):
+- All dev checks
+- Build
+- Release
+
+## Branch Strategy
+
+```
+dev  ← active development (push here)
+  ↓
+prod ← production releases (merge from dev only)
+```
+
+- NEVER push directly to `prod` or `main`
+- The pipeline blocks this and offers to switch to `dev`
+- Merges to `prod` happen through PRs

package/skills/secondary-brain/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: secondary-brain
+description: "Persistent project memory framework. Orchestrates obsidian-skills (Obsidian syntax) + graphify (knowledge graph) to document everything in the vault. Template layer — actual read/write is delegated to those skills."
+argument-hint: "[/woopsy vault|connect|deep|handoff|status]"
+---
+
+# SecondaryBrain — Project Memory Framework — `/woopsy vault`
+
+This skill handles `/woopsy vault` — vault-only operations (project memory, changelog, documentation).
+Also responds to `/woopsy` (part of the full pipeline — see root SKILL.md).
+
+This is the **template/orchestration layer**. We use other skills to **improve our own output quality**:
+
+- **`obsidian-skills`** → teaches us how Obsidian works so we write correct wikilinks, callouts, embeds, properties, Mermaid diagrams. Without it we'd write broken markdown.
+- **`graphify`** → teaches us knowledge graph extraction and entity resolution so we build connected, queryable documentation instead of flat notes.
+
+We don't reinvent markdown or graph logic — we stand on the shoulders of these skills. Every vault file we write goes through their knowledge.
+
+## Dependency Check (Run on First Load)
+
+Before any command, ensure dependencies are installed AND up to date:
+
+```
+required:
+  - https://github.com/kepano/obsidian-skills
+    → skills: obsidian-markdown, obsidian-bases, json-canvas, obsidian-cli, defuddle
+    → purpose: read/write vault with correct Obsidian syntax
+  - https://github.com/Graphify-Labs/graphify
+    → purpose: knowledge graph extraction, entity resolution, graph queries, documentation
+```
+
+### Update step (always run)
+
+For each dependency that exists, pull the latest:
+
+```bash
+cd skills/obsidian && git pull --ff-only
+cd skills/graphify && git pull --ff-only
+```
+
+For each dependency that is missing, clone:
+
+```bash
+git clone --depth 1 https://github.com/kepano/obsidian-skills.git skills/obsidian
+git clone --depth 1 https://github.com/Graphify-Labs/graphify.git skills/graphify
+```
+
+Then install to the current agent by copying SKILL.md files into the agent's skill directory.
+
+Report: `Dependencies: obsidian-skills v<commit> ✓, graphify v<commit> ✓`
+
+## How the Three Skills Work Together
+
+```
+┌─────────────────────────────────────────────────────┐
+│  secondary-brain (this skill)                       │
+│  ├── Template/framework layer                       │
+│  ├── Defines: what to document, when, where          │
+│  ├── Defines: changelog rules, node structure        │
+│  └── Reads/writes: brain-config.json, GLOBAL headers │
+│                                                      │
+│  delegates TO:                                       │
+│  ┌──────────────┐  ┌──────────────────────────────┐  │
+│  │ obsidian-    │  │  graphify                    │  │
+│  │ skills       │  │  └─ Extract entities         │  │
+│  ├─ wikilinks   │  │  └─ Build knowledge graphs   │  │
+│  ├─ callouts    │  │  └─ Query relationships      │  │
+│  ├─ embeds      │  │  └─ Generate graph docs      │  │
+│  ├─ properties  │  │                               │  │
+│  └─ Mermaid     │  └──────────────────────────────┘  │
+│                  │                                    │
+│  produces:       │                                    │
+│  _Changelog/     │  SecondaryBrain/<Project>/ nodes   │
+│  GLOBAL-PROJECT- │  Ai - skills/ patterns             │
+│  MEMORY.md       │                                    │
+└─────────────────────────────────────────────────────┘
+```
+
+## Vault Locations (configured in brain-config.json)
+
+| Location | Path |
+|---|---|
+| Project nodes | `{{VAULT_PATH}}/SecondaryBrain/` |
+| Global memory | `{{VAULT_PATH}}/SecondaryBrain/GLOBAL-PROJECT-MEMORY.md` |
+| Reusable patterns | `{{VAULT_PATH}}/Ai - skills/` |
+| Handoff prompts | `{{VAULT_PATH}}/SecondaryBrain/_ManualPrompting/` |
+| Deep mode rules | `{{VAULT_PATH}}/SecondaryBrain/_System/reference-architecture-protocol.md` |
+| Change log | `{{VAULT_PATH}}/SecondaryBrain/_Changelog/` |
+
+GLOBAL-PROJECT-MEMORY.md is the single source of truth. It MUST always be updated after any change.
+
+## Document Everything — The Change Log Protocol
+
+ALL changes MUST be documented — no exceptions. Every modification, fix, or update goes in TWO places:
+
+### 1. `_Changelog/` — Chronological record
+
+Every interaction creates a dated entry at `_Changelog/YYYY-MM-DD.md`:
+
+```markdown
+# YYYY-MM-DD — Change Log
+
+## Summary
+<one-line summary of what happened this session>
+
+## Changes
+- <file/module> — <what> — <why>
+
+## Decisions
+- <decision made> — <rationale>
+
+## Next
+- <next planned action>
+```
+
+Append to today's file if it exists, create it if not.
+
+### 2. Project cluster — Semantic record
+
+Update the relevant project's node files in `SecondaryBrain/<Project>/`. Keep the GLOBAL-PROJECT-MEMORY.md cluster entry and evolution timeline current.
+
+Use `obsidian-skills` for all formatting (wikilinks, callouts, embeds, properties, Mermaid).
+Use `graphify` for entity extraction and relationship mapping when building documentation.
+
+### Change types and where they go
+
+| Change Type | Changelog Entry | Node Update | GLOBAL Update |
+|---|---|---|---|
+| Bug fix | ✓ Bug fix — what + why | ✓ Update affected node | ✓ Update timeline |
+| Small change | ✓ | ✗ skip if trivial | ✗ skip |
+| New feature | ✓ New feature — what + how | ✓ Create/update feature node | ✓ Update cluster + timeline |
+| Refactor | ✓ Refactor — what + why | ✓ Update architecture node | ✓ Update timeline |
+| Report | ✓ Report — findings | ✓ Create report node | ✓ Add to cluster |
+| Major update | ✓ Major — full breakdown | ✓ Full node refresh | ✓ Full refresh |
+| Config/experiment | ✓ Config change — what changed | ✗ skip | ✗ skip |
+
+## New Session Entry Point
+
+When a user starts a new session and invokes this skill:
+
+1. **Update dependencies** — `git pull --ff-only` on obsidian-skills and graphify
+2. **Load minimal context** (reduced token):
+   ```
+   GLOBAL-PROJECT-MEMORY.md          → read to identify project clusters
+   _Changelog/YYYY-MM-DD.md          → most recent session
+   _Changelog/YYYY-MM-DD.md          → second most recent
+   ```
+3. **Detect current project** from:
+   - Current working directory name → match against `SecondaryBrain/<Project>/` folders
+   - If no match, user prompt: "Which project are you working on?"
+4. **Load only the detected project's hub node** — NOT every cluster, NOT other projects:
+   ```
+   SecondaryBrain/<Project>/<hub-node>.md  → 10-30 lines
+   ```
+5. **Report context**:
+   ```
+   ==============================
+   Dependencies: obsidian-skills ✓, graphify ✓
+   Project: <name> (detected from <dir>)
+   Status: <active|paused|deprecated>
+   Last session: <date> — <summary>
+   Recent: <last 2 changelog entries>
+   ==============================
+   ```
+6. **Confirm with user**: "Continue working on `<project>`?"
+
+## Core Rules
+
+- Think in graphs, timelines, and future evolution
+- Optimize for scalability, modularity, and reuse
+- Document everything — the Changelog is mandatory, no exceptions
+- Every project, module, file, and skill is a NODE in three layers:
+  1. **Logical Graph** — Obsidian `[[wikilinks]]` (use obsidian-skills)
+  2. **Visual Graph** — Mermaid diagrams (use obsidian-skills)
+  3. **Temporal Graph** — evolution timeline
+
+## Slash Commands
+
+### `/woopsy vault` — Vault Only
+
+Triggered by the user typing `/woopsy vault`. Runs ONLY vault operations — no CI/CD, no push.
+
+```
+1. Update dependencies (git pull obsidian-skills + graphify)
+2. Load minimal context (GLOBAL + changelogs + detect project)
+3. Report project state
+4. Wait for user task
+5. After task: document in changelog + update project nodes + refresh GLOBAL
+```
+
+Alias: `connect`
+
+### `/woopsy` — Full Pipeline (vault portion)
+
+When the user types `/woopsy`, the root SKILL.md dispatches. This skill handles the vault portion:
+1. Update dependencies
+2. Connect vault
+3. Document changes
+4. Return control to root for CI/CD steps
+
+## Commands
+
+### `connect` (default — always-on, same as /woopsy vault)
+
+**Pre-Task — before any work:**
+1. Update dependencies (git pull)
+2. Load GLOBAL-PROJECT-MEMORY.md + recent changelogs + detected project's hub node
+3. Report context to user, confirm project
+
+**Post-Task — after ANY change:**
+1. Append to `_Changelog/YYYY-MM-DD.md` with what changed and why
+2. Update or add project node files under `SecondaryBrain/<Project>/` (using obsidian-skills + graphify)
+3. Refresh that project's cluster entry, dependency Mermaid graph, and evolution timeline in GLOBAL-PROJECT-MEMORY.md
+4. Mark superseded nodes as deprecated
+5. When logic repeats across projects, extract as `Ai - skills/<pattern>.md`
+
+**Tooling:** Write ALL vault files using `obsidian-skills` (correct wikilinks, callouts, embeds, properties). Extract ALL structure using `graphify` (entity resolution, graph queries, relationship docs). This skill only defines the template — the other two do the work.
+
+### `deep` — Full Ceremony
+
+Invoke for large refactors, new project bootstrapping, or periodic graph cleanup. Execute the full 10-step pipeline defined in `reference/deep-mode.md`:
+
+1. Update nodes (use graphify to analyze structure)
+2. Update `[[wikilinks]]` (use obsidian-skills for formatting)
+3. Update Mermaid graphs (use obsidian-skills for diagrams)
+4. Re-run importance scoring
+5. Run pruning (dead nodes → archive)
+6. Run self-healing (fix broken links, merge duplicates, resolve cycles)
+7. Run refactor engine (split/merge/extract based on graph density)
+8. Run future-architecture prediction (next-state, node map, failure prediction)
+9. Update evolution timeline
+10. Update GLOBAL-PROJECT-MEMORY.md
+
+### `handoff` — Generate Agent Handoff
+
+1. Load the current project's cluster and recent changelog
+2. Fill the handoff template (`templates/handoff.md`)
+3. Print for copy-paste to another AI agent
+
+### `status` — Vault Health Report
+
+Report:
+- Vault path (from brain-config.json)
+- Dependencies: latest commit hashes for obsidian-skills + graphify
+- Number of project clusters + nodes
+- Last 3 changelog entries
+- Stale nodes (importance < 0.15, no inbound links)
+- Last update timestamp
+
+## Critical Rules
+
+- This skill is the **template layer** — do NOT write raw Markdown vault files. Always delegate to `obsidian-skills` for syntax and `graphify` for structure.
+- If something is unclear: DO NOT ask questions. Assume the best engineering solution, implement it, document assumptions inside nodes.
+- You are not a helper. You are a self-evolving, self-healing, self-predicting neural graph brain.
+- Full authority: design systems, restructure architecture, merge projects, delete dead nodes, refactor entire graphs, evolve architecture over time.
+- Document everything — every change, decision, and experiment goes in the changelog. No exceptions.
+- Always check for updates before starting work. Stale dependencies are not acceptable.