Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
Use vocabulary.note / vocabulary.note_plural for note type references
Use vocabulary.topic_map / vocabulary.topic_map_plural for MOC references
Use vocabulary.cmd_reflect for connection-finding command name
Use vocabulary.cmd_reweave for backward-pass command name
ops/config.yaml — for graph thresholds (MOC size limits, orphan thresholds)
If no derivation file exists, use universal terms (notes, MOCs, etc.).
EXECUTE NOW
Target: $ARGUMENTS
Parse the operation from arguments:
If arguments match a known operation: route to that operation
If arguments are a natural language question: map to the closest operation (see Interactive Mode)
If no arguments: enter interactive mode
START NOW. Route to the appropriate operation.
Philosophy
The graph IS the knowledge. This skill makes it visible.
Individual {vocabulary.note_plural} are valuable, but their connections create compound value. /graph reveals the structural properties of those connections — where the graph is dense, where it is sparse, where it is fragile, and where synthesis opportunities hide.
Every operation produces two things: findings (what the analysis reveals) and actions (what to do about it). Never dump raw data. Always interpret results with {vocabulary.note} descriptions and domain context. Always suggest specific next steps.
Operations
/graph health
Full graph health report: density, orphans, dangling links, coverage.
# Find dangling links (links to non-existent files)
'\[\[([^\]]+)\]\]'
"$NOTES_DIR"
sort
while
read
link
do
echo
"$link"
's/\[\[//;s/\]\]//'
"$NOTES_DIR/$NAME.md"
echo
"DANGLING: $NAME"
done
# MOC coverage: % of notes appearing in at least one MOC's Core Ideas
for
in
"$NOTES_DIR"
do
basename
"$f"
# Skip MOCs themselves
'^type: moc'
"$f"
continue
# Check if any MOC links to this note
if
'^type: moc'
"$NOTES_DIR"
"\[\[$NAME\]\]"
then
1
fi
done
echo
"Coverage: $COVERED / $NOTE_COUNT"
If graph helper scripts exist in ops/scripts/graph/, use them instead of inline analysis:
ops/scripts/graph/link-density.sh for density metrics
ops/scripts/graph/orphan-notes.sh for orphan detection
ops/scripts/graph/dangling-links.sh for dangling link detection
Step 2: Interpret and present
--=={ graph health }==--
{vocabulary.note_plural}: [N] (plus [M] {vocabulary.topic_map_plural})
Connections: [N] (avg [X] per {vocabulary.note})
Graph density: [0.XX]
{vocabulary.topic_map} coverage: [N]% of {vocabulary.note_plural} appear in at least one {vocabulary.topic_map}
Orphans ([N]):
- [[orphan name]] — [description from YAML]
→ Suggestion: Run /{vocabulary.cmd_reflect} to find connections
Dangling Links ([N]):
- [[missing name]] — referenced from [[source note]]
→ Suggestion: Create the {vocabulary.note} or remove the link
{vocabulary.topic_map} Sizes:
- [[moc name]]: [N] {vocabulary.note_plural} [OK | WARN: approaching split threshold | WARN: consider merging]
Overall: [HEALTHY | NEEDS ATTENTION | FRAGMENTED]
Density benchmarks:
Density
Interpretation
< 0.02
Sparse — {vocabulary.note_plural} exist but connections are thin
0.02-0.06
Healthy — growing network with meaningful connections
0.06-0.15
Dense — well-connected, watch for over-linking
> 0.15
Very dense — verify connections are genuine, not noise
/graph triangles
Find synthesis opportunities — open triadic closures where A links to B and A links to C, but B does not link to C.
Step 1: Build adjacency data
# For each note, extract outgoing wiki linksfor f in"$NOTES_DIR"/*.md; do
NAME=$(basename"$f" .md)
LINKS=$(grep -oP '\[\[([^\]]+)\]\]'"$f" 2>/dev/null | sed 's/\[\[//;s/\]\]//' | sort -u)
echo"FROM:$NAME"echo"$LINKS" | whileread -r target; do
[[ -n "$target" ]] && echo" TO:$target"donedone
If ops/scripts/graph/find-triangles.sh exists, use it directly.
Step 2: Find open triangles
For each note A with outgoing links to B and C:
Check if B links to C (in either direction)
Check if C links to B (in either direction)
If neither link exists: this is an open triangle (synthesis opportunity)
Step 3: Evaluate and rank
For each open triangle:
Read descriptions of BOTH unlinked {vocabulary.note_plural}
Assess: is there a genuine conceptual relationship that the common parent suggests?
Rank by potential value: how surprising and useful would the connection be?
Step 4: Present top findings
--=={ graph triangles }==--
Found [N] synthesis opportunities — pairs of {vocabulary.note_plural} that share
a common reference but do not reference each other:
1. [[note B]] and [[note C]]
Common parent: [[note A]]
B: "[description]"
C: "[description]"
→ These may benefit from a connection because [specific reasoning
about WHY B and C might relate through A's lens]
→ Action: Run /{vocabulary.cmd_reflect} on [[note B]] to evaluate
2. [[note D]] and [[note E]]
Common parent: [[note F]]
...
[Show top 10. If more exist: "[N] more triangles found. Show all? (yes/no)"]
Filter out trivial triangles: Skip pairs where:
Both are in the same {vocabulary.topic_map} (they may already be related through the MOC without direct links)
One is a {vocabulary.topic_map} itself (MOCs link to everything, triangles with MOCs are noise)
The descriptions suggest no conceptual overlap
/graph bridges
Identify structurally critical {vocabulary.note_plural} whose removal would disconnect graph regions.
Step 1: Build adjacency list
Build a bidirectional adjacency list from all wiki links in {vocabulary.notes}/.
If ops/scripts/graph/find-bridges.sh exists, use it directly.
Step 2: Find bridge nodes
A bridge note is one where:
Removing it (and its links) would split a connected component into two or more components
It is the SOLE connection between clusters of {vocabulary.note_plural}
Implementation: For each note, temporarily remove it and check if the remaining graph has more connected components.
Step 3: Present findings
--=={ graph bridges }==--
Found [N] bridge {vocabulary.note_plural} — structurally critical nodes whose
removal would disconnect graph regions:
1. [[bridge note]] — connects [N] {vocabulary.note_plural} on one side to [M] on the other
Description: "[description]"
Cluster A: [[note1]], [[note2]], ...
Cluster B: [[note3]], [[note4]], ...
→ Risk: If this {vocabulary.note} becomes stale, [N+M] {vocabulary.note_plural}
lose their connection path
→ Action: Consider adding parallel connections between the clusters
[If no bridges: "No bridge notes found. The graph has redundant paths between
all connected regions. This is healthy."]
/graph clusters
Discover connected components and topic boundaries.
Step 1: Build adjacency list
Build a bidirectional adjacency list from all wiki links.
If ops/scripts/graph/find-clusters.sh exists, use it directly.
Step 2: Find connected components
Use BFS/DFS to find all connected components:
Start with any unvisited note
Traverse all reachable notes via wiki links (bidirectional)
Mark as one component
Repeat until all notes visited
Step 3: Analyze clusters
For each cluster:
Size (number of {vocabulary.note_plural})
Key {vocabulary.note_plural} (highest link count within cluster)
Topic coverage (which {vocabulary.topic_map_plural} are represented)
Isolation level (how many links cross cluster boundaries)
Step 4: Present findings
--=={ graph clusters }==--
Found [N] connected components:
Cluster 1: [size] {vocabulary.note_plural}
Key nodes: [[note1]] (8 links), [[note2]] (6 links)
Topics: [[topic A]], [[topic B]]
Cross-cluster links: [N]
→ This cluster is [well-connected | isolated | a hub]
Cluster 2: [size] {vocabulary.note_plural}
...
Isolated {vocabulary.note_plural} ([N]):
- [[isolated note]] — [description]
→ Action: Run /{vocabulary.cmd_reflect} to find connections
[If 1 cluster: "All {vocabulary.note_plural} are in one connected component.
The graph is fully connected. This is healthy."]
/graph hubs
Rank {vocabulary.note_plural} by influence — most-linked-to (authorities) and most-linking-from (hubs).
Step 1: Count links
# Authority score: incoming links per notefor f in"$NOTES_DIR"/*.md; do
NAME=$(basename"$f" .md)
INCOMING=$(grep -rl "\[\[$NAME\]\]""$NOTES_DIR"/ 2>/dev/null | grep -v "$f" | wc -l | tr -d ' ')
echo"AUTH:$INCOMING:$NAME"done | sort -t: -k2 -rn | head -10
# Hub score: outgoing links per notefor f in"$NOTES_DIR"/*.md; do
NAME=$(basename"$f" .md)
OUTGOING=$(grep -oP '\[\[[^\]]+\]\]'"$f" 2>/dev/null | wc -l | tr -d ' ')
echo"HUB:$OUTGOING:$NAME"done | sort -t: -k2 -rn | head -10
If ops/scripts/graph/influence-flow.sh exists, use it directly.
Step 2: Identify synthesizers
Synthesizer {vocabulary.note_plural} score high on BOTH metrics — they absorb many inputs (high authority) and produce many outputs (high hub). These are the most structurally important {vocabulary.note_plural} in the graph.
Step 3: Present findings
--=={ graph hubs }==--
Top Authorities (most-linked-to):
1. [[note]] — [N] incoming links — "[description]"
2. [[note]] — [N] incoming links — "[description]"
...
Top Hubs (most-linking-from):
1. [[note]] — [N] outgoing links — "[description]"
2. [[note]] — [N] outgoing links — "[description]"
...
Synthesizers (high on both — structurally important):
1. [[note]] — [N] in / [M] out — "[description]"
...
[If no clear synthesizers: "No notes score high on both metrics.
This suggests the graph has separate input and output layers."]
/graph siblings [[topic]]
Find unconnected {vocabulary.note_plural} within a topic — {vocabulary.note_plural} sharing the same {vocabulary.topic_map} but not linking to each other.
Step 1: Read the specified {vocabulary.topic_map}
Find and read the {vocabulary.topic_map} matching the argument. Extract all {vocabulary.note_plural} linked in Core Ideas.
Step 2: Check pairwise connections
For each pair of {vocabulary.note_plural} in the {vocabulary.topic_map}:
Does A link to B? (grep for [[B]] in A's file)
Does B link to A? (grep for [[A]] in B's file)
If neither: this is an unconnected sibling pair
If ops/scripts/graph/topic-siblings.sh exists, use it with the topic argument.
Step 3: Evaluate pairs
For each unconnected pair:
Read both descriptions
Assess whether a connection SHOULD exist
Rate as: likely connection, possible connection, appropriately separate
Step 4: Present findings
--=={ graph siblings: [[topic]] }==--
{vocabulary.topic_map} [[topic]] has [N] {vocabulary.note_plural}.
Found [M] unconnected sibling pairs:
Likely connections:
1. [[note A]] and [[note B]]
A: "[description]"
B: "[description]"
→ [Why these likely relate]
Possible connections:
2. [[note C]] and [[note D]]
...
Appropriately separate: [N] pairs — no connection needed
→ Action: Run /{vocabulary.cmd_reflect} on the "likely" pairs
/graph forward [[note]] [depth]
N-hop forward traversal from a {vocabulary.note}. Default depth: 2.
Step 1: Start from the specified {vocabulary.note}
Read the {vocabulary.note} and extract all outgoing wiki links (hop 1).
If ops/scripts/graph/n-hop-forward.sh exists, use it with the note and depth arguments.
Step 2: Traverse
For each linked {vocabulary.note}:
Read it and extract its outgoing wiki links (hop 2)
For each matching file, extract the description for context.
Step 3: Present results
--=={ graph query: {field} = {value} }==--
Found [N] {vocabulary.note_plural}:
1. [[note name]] — "[description]"
2. [[note name]] — "[description]"
...
Distribution:
[If querying topics: how many per sub-topic]
[If querying type: breakdown by status]
[If querying methodology: breakdown by tradition]
Interactive Mode
If no arguments provided:
Ask: "What would you like to know about your knowledge graph?"
Map natural language to operation:
User Says
Maps To
Why
"Where should I look for connections?"
triangles
Finding synthesis opportunities
"What are my most important notes?"
hubs
Authority/hub ranking
"Are there isolated areas?"
clusters
Connected component detection
"How healthy is my graph?"
health
Full health report
"What bridges my topics?"
bridges
Bridge note identification
"What connects to [[X]]?"
backward [[X]]
Backward traversal
"Where does [[X]] lead?"
forward [[X]]
Forward traversal
"Show me notes about [topic]"
query topics [[topic]]
Schema query
"What needs connecting in [topic]?"
siblings [[topic]]
Unconnected sibling pairs
Run the mapped operation
After presenting results, offer follow-up: "Want to explore any of these further?"
Output Rules
Never dump raw data. Always interpret results with {vocabulary.note} descriptions and context.
Always suggest actions. "Run /{vocabulary.cmd_reflect} on these pairs" or "Consider adding a bridge {vocabulary.note} about X."
Use domain vocabulary for all labels and descriptions — {vocabulary.note}, {vocabulary.topic_map}, etc.
For large result sets, summarize top findings (max 10) and offer to show more: "[N] more results. Show all? (yes/no)"
Include density benchmarks for context — "your density of 0.04 is in the healthy range."
Distinguish structural from semantic. Graph analysis reveals structural properties. Semantic judgment about WHETHER connections should exist requires /{vocabulary.cmd_reflect}.
Edge Cases
Small Vault (<10 notes)
Report metrics but contextualize: "With [N] {vocabulary.note_plural}, graph analysis provides limited insight. Graph operations become more valuable as the knowledge graph grows. Current metrics are baseline measurements."
All operations still run — they just produce less data.
No Graph Scripts Available
If ops/scripts/graph/ does not exist or individual scripts are missing, implement the analysis inline using grep, file reads, and bash loops as shown in each operation's steps. The inline implementations are complete — scripts are optimization, not requirements.
No ops/derivation-manifest.md
Use universal vocabulary (notes, MOCs, etc.). All operations work identically.
Empty Notes Directory
Report: "No {vocabulary.note_plural} found in {vocabulary.notes}/. Start by capturing content to build your knowledge graph."
Note Not Found (for forward/backward/siblings)
If the specified {vocabulary.note} or {vocabulary.topic_map} does not exist:
Search for partial matches: ls "$NOTES_DIR"/*{query}*.md 2>/dev/null
If matches found: "Did you mean: [[match1]], [[match2]]?"
If no matches: "{vocabulary.note} '[[name]]' not found. Check the name and try again."