Implement Chain Workbench and Vault Triage features in Mindnet plugin
Node.js build / build (20.x) (push) Waiting to run
Node.js build / build (22.x) (push) Waiting to run

- Introduced new workflows for Chain Workbench and Vault Triage, enhancing user capabilities for managing template matches and identifying chain gaps.
- Added commands for opening the Chain Workbench and scanning the vault for chain gaps, improving the overall functionality of the plugin.
- Updated documentation to include detailed instructions for the new workflows, ensuring users can effectively utilize the features.
- Enhanced the UI for both the Chain Workbench and Vault Triage Scan, providing a more intuitive user experience.
- Implemented tests for the new functionalities to ensure reliability and accuracy in various scenarios.
This commit is contained in:
Lars committed 2026-01-26 10:51:12 +01:00
1 parent 327ff4c9c7
commit a9b3e2f0e2
25 files changed
+6202 -12

No files matched your search

+50
View File
@@ -264,6 +264,54 @@ Inhalt mit Links: [[Note1]] und [[Note2]]
- Verfügbare Actions auswählen
- Automatische Behebung
### Workflow 5: Chain Workbench verwenden (Neu in 0.5.x)
1. **Section öffnen:**
- Cursor in relevante Section positionieren
2. **Chain Workbench öffnen:**
- Command: "Mindnet: Chain Workbench (Current Section)"
- Modal zeigt alle Template Matches
3. **Matches analysieren:**
- Filter nach Status (complete, near_complete, partial, weak)
- Suche nach Template-Name
- Match auswählen → Details anzeigen
4. **Todos bearbeiten:**
- Todo auswählen
- Action wählen (z.B. "Insert Edge", "Create Note", "Promote Candidate")
- Apply → Workbench aktualisiert sich automatisch
5. **Wiederholen:**
- Weitere Todos bearbeiten
- Status verbessert sich nach jedem Apply
### Workflow 6: Vault Triage Scan (Neu in 0.5.x)
1. **Scan starten:**
- Command: "Mindnet: Scan Vault for Chain Gaps"
- Modal öffnet sich
2. **Scan durchführen:**
- Klicke "Start Scan"
- Progress wird angezeigt
- Scan kann unterbrochen werden
3. **Backlog durchsuchen:**
- Filter nach Status, Gap-Typen
- Suche nach File, Heading, Template
- Sortierung: near_complete zuerst
4. **Items bearbeiten:**
- "Open Workbench" → öffnet Datei und Workbench
- "Deprioritize" → markiert als nicht fokussiert
- Items bleiben im Backlog (werden gefiltert)
5. **Resume:**
- Scan kann fortgesetzt werden (wenn unterbrochen)
- State wird gespeichert
### Workflow 3: Unresolved Link → Note erstellen
1. **Link erstellen:**
@@ -323,6 +371,8 @@ Inhalt mit Links: [[Note1]] und [[Note2]]
| Command | Beschreibung | Wann verwenden |
|---------|--------------|----------------|
| **Mindnet: Inspect Chains (Current Section)** | Analysiert kausale Ketten | Chain-Analyse durchführen |
| **Mindnet: Chain Workbench (Current Section)** | Workbench für alle Template Matches mit Todos | Chain-Gaps identifizieren und beheben |
| **Mindnet: Scan Vault for Chain Gaps** | Scannt gesamten Vault nach Chain-Gaps | Vault-weites Backlog erstellen |
| **Mindnet: Fix Findings (Current Section)** | Behebt Findings automatisch | Findings automatisch beheben |
| **Mindnet: Validate current note** | Validiert aktuelle Note (Lint) | Note auf Fehler prüfen |
@@ -0,0 +1,393 @@
# Chain-Identifikation und Template Matching
## Übersicht
Das System identifiziert und füllt Chains durch einen mehrstufigen Prozess:
1. **Graph-Indexierung**: Erfassung aller Edges (Kanten) im lokalen Subgraph
2. **Candidate-Node-Sammlung**: Identifikation potenzieller Knoten für Template-Slots
3. **Template Matching**: Backtracking-Algorithmus zur optimalen Slot-Zuordnung
4. **Link-Validierung**: Prüfung, ob Edges zwischen zugewiesenen Slots existieren
5. **Scoring & Confidence**: Bewertung der Match-Qualität
---
## 1. Graph-Indexierung
### Edge-Erfassung
Der **Chain Inspector** (`src/analysis/chainInspector.ts`) erfasst alle Edges im lokalen Subgraph:
- **Current Section**: Die aktuelle Section (file + heading)
- **Incoming Edges**: Edges, die zur aktuellen Section zeigen
- **Outgoing Edges**: Edges, die von der aktuellen Section ausgehen
- **Neighbor Notes**: Verbundene Notes werden geladen, um den Subgraph zu erweitern
### Edge-Scopes
Edges können drei Scopes haben:
- **`section`**: Section-spezifisch (`[[Note#Heading]]`)
- **`note`**: Note-weit (`[[Note]]` ohne Heading)
- **`candidate`**: In "## Kandidaten" Zone
### Filterung
Edges werden basierend auf `InspectorOptions` gefiltert:
- `includeNoteLinks`: Ob Note-Scope Edges einbezogen werden
- `includeCandidates`: Ob Candidate Edges einbezogen werden
- `maxDepth`: Maximale Tiefe für Path-Traversal
---
## 2. Candidate-Node-Sammlung
### Prozess (`buildCandidateNodes`)
Für jeden Edge im Subgraph werden **Candidate Nodes** erstellt:
1. **Source Nodes**: Alle Knoten, von denen Edges ausgehen
2. **Target Nodes**: Alle Knoten, zu denen Edges zeigen
3. **Note-Type-Extraktion**: Frontmatter `type:` wird aus jeder Note extrahiert
4. **Deduplizierung**: Gleiche Knoten (file + heading) werden nur einmal erfasst
### Node-Repräsentation
```typescript
interface CandidateNode {
nodeKey: {
file: string;
heading: string | null;
};
noteType: string; // z.B. "insight", "decision", "experience"
}
```
### Maximale Anzahl
Standardmäßig werden maximal **30 Candidate Nodes** gesammelt (konfigurierbar).
---
## 3. Template Matching
### Template-Definition (`chain_templates.yaml`)
Jedes Template definiert:
- **Slots**: Positionen in der Chain mit erlaubten Note-Types
- **Links**: Erwartete Verbindungen zwischen Slots mit erlaubten Edge-Roles
**Beispiel: `loop_learning`**
```yaml
slots:
- id: experience
allowed_node_types: [experience, journal, event]
- id: learning
allowed_node_types: [insight, principle, value, belief, skill, trait]
- id: behavior
allowed_node_types: [habit, decision, task]
- id: feedback
allowed_node_types: [experience, journal, event, state]
links:
- from: experience
to: learning
allowed_edge_roles: [causal, provenance, influences]
- from: learning
to: behavior
allowed_edge_roles: [influences, enables_constraints, causal]
- from: behavior
to: feedback
allowed_edge_roles: [causal, influences]
```
### Backtracking-Algorithmus (`findBestAssignment`)
Der Algorithmus findet die **beste Slot-Zuordnung** durch systematisches Ausprobieren:
1. **Slot-Filterung**: Für jeden Slot werden nur Candidate Nodes gefiltert, die den `allowed_node_types` entsprechen
2. **Backtracking**: Rekursives Durchprobieren aller möglichen Zuordnungen
3. **Distinct Nodes**: Jeder Knoten kann nur einmal zugeordnet werden (wenn `distinct_nodes: true`)
4. **Scoring**: Jede vollständige Zuordnung wird bewertet
5. **Best Match**: Die Zuordnung mit dem höchsten Score wird zurückgegeben
### Slot-Zuordnung
```typescript
function backtrack(assignment: Map<string, CandidateNode>, slotIndex: number) {
// Wenn alle Slots zugeordnet sind:
if (slotIndex >= slots.length) {
const result = scoreAssignment(...); // Bewerte Zuordnung
if (result.score > bestScore) {
bestMatch = result; // Speichere besten Match
}
return;
}
// Probiere jeden passenden Candidate für diesen Slot
for (const candidate of slotCandidates.get(slot.id)) {
if (!alreadyAssigned(candidate)) {
assignment.set(slot.id, candidate);
backtrack(assignment, slotIndex + 1); // Rekursiv weiter
assignment.delete(slot.id); // Backtrack
}
}
// Auch: Slot leer lassen (für unvollständige Chains)
backtrack(assignment, slotIndex + 1);
}
```
---
## 4. Link-Validierung
### Edge-Suche (`findEdgeBetween`)
Für jedes Template-Link wird geprüft, ob ein Edge zwischen den zugewiesenen Slots existiert:
1. **Node-Keys**: `fromKey = "file:heading"`, `toKey = "file:heading"`
2. **Edge-Suche**: Durchsuche `allEdges` nach passendem Edge
3. **Canonicalisierung**: Edge-Typ wird auf Canonical gemappt (via `edge_vocabulary.md`)
4. **Role-Mapping**: Canonical Edge-Typ wird auf Role gemappt (via `chain_roles.yaml`)
5. **Role-Validierung**: Prüfe, ob Edge-Role in `allowed_edge_roles` enthalten ist
### Role-Evidence
Wenn ein Link erfüllt ist, wird **Role Evidence** gespeichert:
```typescript
roleEvidence.push({
from: "learning", // Slot-ID (nicht Dateipfad!)
to: "behavior", // Slot-ID
edgeRole: "causal", // Role aus chain_roles.yaml
rawEdgeType: "resulted_in" // Original Edge-Typ im Vault
});
```
**Wichtig**: `roleEvidence` verwendet **Slot-IDs**, nicht Dateipfade!
---
## 5. Scoring & Confidence
### Scoring (`scoreAssignment`)
**Slot-Scoring**:
- Jeder zugewiesene Slot: **+2 Punkte**
**Link-Scoring**:
- Erfüllter Link (mit erlaubter Role): **+10 Punkte**
- Fehlender Link (wenn `required_links: true`): **-5 Punkte**
- Falsche Role (wenn `required_links: true`): **-5 Punkte**
### Confidence-Berechnung
Die **Confidence** wird nach dem Matching berechnet:
1. **`weak`**: Wenn `slotsComplete === false` (fehlende Slots)
2. **`confirmed`**: Wenn `slotsComplete === true` UND `linksComplete === true` UND mindestens eine causal-ish Role Evidence
3. **`plausible`**: Sonst (Slots vollständig, aber Links unvollständig oder keine causal Roles)
**Causal-ish Roles**: `["causal", "influences", "enables_constraints"]` (konfigurierbar in `chain_templates.yaml`)
### Completeness
- **`slotsComplete`**: `missingSlots.length === 0`
- **`linksComplete`**: `satisfiedLinks === requiredLinks`
---
## 6. Template-Matching-Profile
### Profile-Definition
Profile steuern die Matching-Strenge:
**`discovery`** (schreibfreundlich):
```yaml
required_links: false # Links sind optional
min_slots_filled_for_gap_findings: 2
min_score_for_gap_findings: 8
```
**`decisioning`** (strikt):
```yaml
required_links: true # Links sind Pflicht
min_slots_filled_for_gap_findings: 3
min_score_for_gap_findings: 18
```
### Profile-Auflösung
1. **Settings**: Plugin-Einstellung `templateMatchingProfile`
2. **Template**: Template-spezifische `matching.required_links`
3. **Defaults**: `defaults.matching.required_links`
---
## 7. Beispiel: Loop Learning Match
### Input
- **Current Section**: `Tests/03_insight_transformation.md#Kern`
- **Edges im Subgraph**: 8 Edges (1 current, 7 neighbors)
- **Candidate Nodes**: 4 Nodes (experience, learning, behavior, feedback)
### Template
```yaml
name: loop_learning
slots: [experience, learning, behavior, feedback]
links:
- experience → learning
- learning → behavior
- behavior → feedback
```
### Matching-Prozess
1. **Slot-Zuordnung** (Backtracking):
- `experience` → `Tests/02_event_trigger_detail.md#Detail` (noteType: `event`)
- `learning` → `Tests/03_insight_transformation.md#Kern` (noteType: `insight`)
- `behavior` → `Tests/04_decision_outcome.md#Entscheidung` (noteType: `decision`)
- `feedback` → `Tests/01_experience_trigger.md#Kontext` (noteType: `experience`)
2. **Link-Validierung**:
- `experience → learning`: ❌ Kein Edge gefunden
- `learning → behavior`: ✅ Edge `resulted_in` mit Role `causal` gefunden
- `behavior → feedback`: ❌ Kein Edge gefunden
3. **Scoring**:
- Slots: 4 × 2 = **8 Punkte**
- Links: 1 × 10 = **10 Punkte**
- **Gesamt: 18 Punkte**
4. **Resultat**:
```json
{
"templateName": "loop_learning",
"score": 18,
"slotsComplete": true,
"linksComplete": false,
"satisfiedLinks": 1,
"requiredLinks": 3,
"confidence": "plausible",
"roleEvidence": [
{
"from": "learning",
"to": "behavior",
"edgeRole": "causal",
"rawEdgeType": "resulted_in"
}
]
}
```
---
## 8. Wichtige Konzepte
### Slot-IDs vs. Dateipfade
- **Slot-IDs**: Template-interne Bezeichner (`"learning"`, `"behavior"`)
- **Dateipfade**: Vault-Pfade (`"Tests/03_insight_transformation.md"`)
- **roleEvidence** verwendet Slot-IDs, nicht Dateipfade!
### Canonicalisierung
- **Intern**: Edge-Typen werden auf Canonical gemappt (für Analyse)
- **Vault**: Original Edge-Typen (Aliase) bleiben unverändert
- **Schreiben**: Plugin schreibt keine Canonicals, nur User-gewählte Typen
### Distinct Nodes
Wenn `distinct_nodes: true`:
- Jeder Knoten kann nur **einmal** pro Template zugeordnet werden
- Verhindert zirkuläre Zuordnungen
### Edge-Target-Resolution
Edges können verschiedene Pfad-Formate verwenden:
- Vollständig: `Tests/03_insight_transformation.md`
- Basename: `03_insight_transformation`
- Wikilink: `[[03_insight_transformation]]`
Das System normalisiert alle Formate für konsistente Matching.
---
## 9. Integration mit Chain Workbench
Der **Chain Workbench** nutzt die Template Matches, um:
1. **Todos zu generieren**:
- `missing_slot`: Fehlende Slot-Zuordnungen
- `missing_link`: Fehlende Links zwischen Slots
- `weak_roles`: Links mit schwachen (nicht-causalen) Roles
2. **Status zu berechnen**:
- `complete`: Slots + Links vollständig
- `near_complete`: 1-2 Links fehlen oder 1 Slot fehlt
- `partial`: Mehrere Lücken
- `weak`: Nur structural/temporal Roles, keine causal Roles
3. **Actions anzubieten**:
- `insert_edge_forward`: Edge einfügen (von Slot A nach Slot B)
- `link_existing`: Bestehenden Knoten verlinken
- `create_note_via_interview`: Neue Note für Slot erstellen
---
## 10. Konfigurationsdateien
### `chain_templates.yaml`
Definiert Template-Strukturen:
- Slots mit erlaubten Note-Types
- Links mit erlaubten Edge-Roles
- Profile (discovery, decisioning)
### `chain_roles.yaml`
Mappt Edge-Typen auf Roles:
- `causal`: Direkte Kausalität
- `influences`: Indirekte Einflussnahme
- `enables_constraints`: Ermöglicht/Einschränkt
- `structural`: Strukturelle Beziehung
- `temporal`: Zeitliche Beziehung
### `edge_vocabulary.md`
Definiert Canonical Edge-Typen und Aliase:
- Canonical: `resulted_in`
- Aliase: `führt_zu`, `resultiert_in`, etc.
### `graph_schema.md`
Definiert Note-Type-Kompatibilität:
- Welche Edge-Typen sind typisch für `insight → decision`?
- Welche Edge-Typen sind verboten?
---
## Zusammenfassung
Das System identifiziert Chains durch:
1. **Graph-Indexierung**: Erfassung aller Edges im lokalen Subgraph
2. **Candidate-Sammlung**: Identifikation potenzieller Knoten
3. **Backtracking-Matching**: Optimale Slot-Zuordnung
4. **Link-Validierung**: Prüfung vorhandener Edges
5. **Scoring**: Bewertung der Match-Qualität
Das Ergebnis sind **Template Matches** mit:
- Slot-Zuordnungen (welche Knoten in welchen Slots)
- Link-Status (welche Links erfüllt/fehlend)
- Confidence (confirmed/plausible/weak)
- Role Evidence (welche Edges welche Roles haben)
Diese Matches werden dann im **Chain Workbench** verwendet, um konkrete Todos und Actions zu generieren.
+2 -2
View File
@@ -151,9 +151,9 @@ npm run lint
### Development Workflow
1. **Code ändern** in `src/`
2. **Watch Mode** läuft (`npm run dev`)
2. **Watch Mode** läuft (`npm.cmd run dev`)
3. **Automatisches Rebuild** bei Dateiänderungen
4. **Deploy lokal** (`npm run deploy:local` oder `npm run build:deploy`)
4. **Deploy lokal** (`npm.cmd run deploy:local` oder `npm.cmd run build:deploy`)
5. **Obsidian Plugin reload** (disable/enable)
6. **Testen**
+309
View File
@@ -0,0 +1,309 @@
# Testing Chain Workbench + Vault Triage (0.5.x)
Diese Anleitung beschreibt, wie du die neuen Chain Workbench und Vault Triage Features in Obsidian testen kannst.
## Voraussetzungen
1. **Node.js** installiert (LTS Version empfohlen)
2. **Obsidian** installiert
3. **Vault** mit Mindnet-konfigurierten Dateien:
- `Dictionary/chain_templates.yaml`
- `Dictionary/chain_roles.yaml`
- `Dictionary/edge_vocabulary.md`
- `Dictionary/analysis_policies.yaml` (optional)
- `Dictionary/interview_config.yaml` (für Interview-Features)
## Build & Installation
### 1. Dependencies installieren
```bash
cd c:\Dev\cursor\mindnet_obsidian
npm install
```
### 2. Plugin bauen
```bash
npm run build
```
Dies erstellt `main.js` im Projekt-Root.
### 3. Plugin in Obsidian installieren
**Option A: Lokales Deployment (empfohlen für Entwicklung)**
```powershell
npm run deploy:local
```
Dies kopiert automatisch `main.js`, `manifest.json` und `styles.css` (falls vorhanden) in dein Test-Vault.
**Option B: Manuell**
1. Öffne dein Obsidian Vault
2. Gehe zu `.obsidian/plugins/`
3. Erstelle Ordner `mindnet-causal-assistant` (falls nicht vorhanden)
4. Kopiere folgende Dateien:
- `main.js` (aus Projekt-Root)
- `manifest.json` (aus Projekt-Root)
- `styles.css` (falls vorhanden)
### 4. Plugin aktivieren
1. Öffne Obsidian Settings
2. Gehe zu **Community plugins**
3. Aktiviere **Mindnet Causal Assistant**
4. Stelle sicher, dass die Dictionary-Pfade korrekt konfiguriert sind:
- Edge Vocabulary Path: `Dictionary/edge_vocabulary.md`
- Chain Templates Path: `Dictionary/chain_templates.yaml`
- Chain Roles Path: `Dictionary/chain_roles.yaml`
- Interview Config Path: `Dictionary/interview_config.yaml`
## Testing Chain Workbench
### Schritt 1: Test-Vault vorbereiten
Erstelle oder öffne eine Note mit:
- Mindestens einer Section (H2-Überschrift)
- Einigen Edges (z.B. in Semantic Mapping Block)
- Optional: Candidate Edges in "## Kandidaten" Zone
**Beispiel-Note:**
```markdown
---
id: test_note_001
type: concept
---
# Test Note
## Kontext
Dies ist eine Test-Section mit einigen Links.
> [!abstract]- 🕸️ Semantic Mapping
>> [!edge] caused_by
>> [[Target Note 1]]
## Kandidaten
> [!abstract]
>> [!edge] impacts
>> [[Target Note 2]]
```
### Schritt 2: Chain Workbench öffnen
1. Öffne die Test-Note im Editor
2. Setze den Cursor in eine Section (z.B. "Kontext")
3. Öffne Command Palette (`Ctrl+P` / `Cmd+P`)
4. Suche nach: **"Mindnet: Chain Workbench (Current Section)"**
5. Klicke auf den Command
### Schritt 3: Workbench UI verwenden
**Erwartetes Verhalten:**
- Modal öffnet sich mit:
- Links: Liste aller Template Matches
- Rechts: Details des ausgewählten Matches
- Filter nach Status verfügbar
- Suche nach Template-Name funktioniert
**Zu testen:**
1. **Match-Liste**:
- Alle Matches werden angezeigt (nicht nur Top-1)
- Status-Icons sind korrekt (✓, ~, ○, ⚠)
- Sortierung: near_complete zuerst
2. **Match-Details**:
- Slots-Info korrekt angezeigt
- Links-Info korrekt angezeigt
- Todos werden aufgelistet
3. **Todo-Actions**:
- Klicke auf "Insert Edge" für `missing_link` Todo
- Wähle Zone (Section / Note-Verbindungen / Kandidaten)
- Wähle Edge-Typ
- Prüfe: Edge wurde eingefügt
- Prüfe: Workbench aktualisiert sich nach Apply
4. **Candidate Promotion**:
- Wenn Candidate Edge vorhanden, sollte `candidate_cleanup` Todo erscheinen
- Klicke auf "Promote"
- Prüfe: Candidate wurde zu explizitem Edge befördert
- Prüfe: Candidate wurde aus Kandidaten-Zone entfernt (wenn `keepOriginal=false`)
## Testing Interview-Orchestrierung
### Schritt 1: Missing Slot Todo erstellen
1. Öffne Chain Workbench für eine Section mit fehlendem Slot
2. Wähle einen Match mit `missing_slot` Todo
### Schritt 2: Create Note via Interview
1. Klicke auf "Create Note" Button
2. **Erwartetes Verhalten**:
- Profile Selection Modal öffnet sich
- Nur erlaubte Profile werden angezeigt (gefiltert nach `allowedNodeTypes`)
- User wählt Profile, Titel, Ordner
3. **Nach Auswahl**:
- Note wird erstellt mit Frontmatter
- Zonen werden erstellt (je nach Settings)
- Interview Wizard startet automatisch
4. **Nach Interview-Abschluss**:
- Soft-Validation prüft requiredEdges
- Notice zeigt fehlende Edges (falls vorhanden)
**Zu testen:**
- Profile-Filterung funktioniert
- Note wird korrekt erstellt
- Interview startet
- Soft-Validation zeigt korrekte Meldungen
## Testing Vault Triage Scan
### Schritt 1: Scan starten
1. Öffne Command Palette
2. Suche nach: **"Mindnet: Scan Vault for Chain Gaps"**
3. Klicke auf den Command
### Schritt 2: Scan durchführen
**Erwartetes Verhalten:**
- Modal öffnet sich
- "Start Scan" Button verfügbar
- Nach Klick: Scan läuft durch alle Dateien
- Progress wird angezeigt
**Zu testen:**
1. **Scan-Prozess**:
- Progress wird aktualisiert
- Aktuelle Datei wird angezeigt
- Scan kann unterbrochen werden (Cancel)
2. **Backlog-Liste**:
- Items werden nach Scan angezeigt
- Sortierung: near_complete zuerst
- Gap-Counts sind korrekt
3. **Filter**:
- Status-Filter funktioniert
- Gap-Typ-Filter funktioniert (missing_slot, missing_link, etc.)
- Suche funktioniert (File, Heading, Template)
4. **Actions**:
- "Open Workbench" öffnet Datei und Workbench
- "Deprioritize" markiert Item als deprioritized
- Item verschwindet nicht, sondern wird gefiltert
5. **Resume**:
- Schließe Modal während Scan läuft
- Öffne Scan erneut
- "Resume Scan" sollte verfügbar sein
- Scan setzt fort
## Troubleshooting
### Plugin lädt nicht
- Prüfe: `main.js` existiert im Plugin-Ordner
- Prüfe: `manifest.json` ist vorhanden
- Prüfe: Console (F12) für Fehler
- Prüfe: Plugin ist in Settings aktiviert
### Chain Workbench zeigt keine Matches
- Prüfe: Chain Templates sind geladen (Settings → Dictionary Paths)
- Prüfe: Section hat Edges oder Links
- Prüfe: Console für Fehler
- Prüfe: Template Matching Profile ist korrekt
### Interview startet nicht
- Prüfe: Interview Config ist geladen
- Prüfe: Profile existiert für gewählten noteType
- Prüfe: Settings → `autoStartInterviewOnCreate` ist aktiviert
### Vault Scan ist langsam
- Normal für große Vaults
- Scan kann unterbrochen werden
- Progress wird gespeichert für Resume
### Edge wird nicht eingefügt
- Prüfe: Zone existiert oder wird erstellt
- Prüfe: Section hat Semantic Mapping Block oder wird erstellt
- Prüfe: Console für Fehler
- Prüfe: File-Berechtigungen
## Debug-Modus
Für detaillierte Logs:
1. Öffne Obsidian Console (F12)
2. Aktiviere Debug-Logging in Settings:
- Settings → Mindnet Settings → Debug Logging
**Wichtige Console-Logs:**
- `[Chain Workbench]` - Workbench-Operationen
- `[Vault Triage Scan]` - Scan-Operationen
- `[Chain Inspector]` - Template Matching
- `[Workbench]` - Todo-Generierung
## Beispiel-Workflow
1. **Erstelle Test-Note** mit unvollständiger Chain:
```markdown
## Kontext
Content hier.
> [!abstract]- 🕸️ Semantic Mapping
>> [!edge] caused_by
>> [[Note A]]
```
2. **Öffne Chain Workbench** für diese Section
3. **Erwartung**:
- Match für Template (z.B. `trigger_transformation_outcome`)
- Status: `partial` oder `near_complete`
- Todos: `missing_slot` für "transformation" oder "outcome"
4. **Teste Actions**:
- Klicke "Create Note" → Interview startet
- Oder: Klicke "Insert Edge" → Edge wird eingefügt
5. **Nach Apply**:
- Workbench aktualisiert sich automatisch
- Match-Status verbessert sich (z.B. `partial` → `near_complete`)
## Nächste Schritte
Nach erfolgreichem Test:
1. Teste mit realen Vault-Daten
2. Prüfe Performance bei großen Vaults
3. Teste Edge-Cases (leere Sections, fehlende Zonen, etc.)
4. Gib Feedback zu UX/UI
## Bekannte Einschränkungen
- `link_existing` ist noch Placeholder (fügt Link ein, aber Slot-Assignment erfordert Re-Run)
- Interview Quick-Insert (requiredEdges) ist vorbereitet, aber noch nicht vollständig integriert
- `insert_edge_inverse` noch nicht implementiert
- `change_edge_type` noch nicht implementiert
Diese Features werden in späteren Iterationen vervollständigt.
+278
View File
@@ -0,0 +1,278 @@
# Chain Workbench - Analyse-Basis und Erweiterungen
> **Version:** 0.5.x
> **Stand:** 2025-01-XX
> **Zielgruppe:** Entwickler, Architekten
---
## Übersicht
Die Chain Workbench (0.5.x) basiert **hauptsächlich** auf den Analysen aus Chain Inspector (0.4.x), erweitert diese aber um zusätzliche Heuristiken und granularere Todo-Generierung.
---
## Basis: Chain Inspector 0.4.x Analysen
### Template Matching (0.4.x)
Die Workbench nutzt direkt die **Template Matches** aus Chain Inspector:
- **`TemplateMatch` Interface:**
- `templateName`: Name des Templates
- `score`: Match-Score (+10 pro Link, +2 pro Slot, -5 pro fehlendem required Link)
- `slotAssignments`: Map von Slot-ID → Node-Referenz
- `missingSlots`: Array von fehlenden Slot-IDs
- `satisfiedLinks`: Anzahl erfüllter Links
- `requiredLinks`: Anzahl erforderlicher Links
- `roleEvidence`: Array von Edge-Role-Evidence
- `slotsComplete`: Boolean
- `linksComplete`: Boolean
- `confidence`: "confirmed" | "plausible" | "weak"
**Quelle:** `src/analysis/chainInspector.ts` → `inspectChains()` → `matchTemplates()`
### Findings aus 0.4.x (aktuell NICHT verwendet, aber sollten integriert werden)
**Status:** Die Findings aus Chain Inspector werden aktuell **nicht** in der Workbench verwendet, obwohl sie aufwendig getestet wurden und wertvolle Informationen liefern.
**Findings aus 0.4.x:**
- `missing_edges` - Section hat Content aber keine Edges
- `one_sided_connectivity` - Nur incoming oder nur outgoing edges
- `only_candidates` - Nur Candidate-Edges, keine expliziten
- `dangling_target` - Target-Datei existiert nicht
- `dangling_target_heading` - Target-Heading existiert nicht
- `no_causal_roles` - Section hat Edges aber keine kausalen Rollen
- `missing_slot_<slotId>` - Template-basiert: Slot fehlt (aggregiert)
- `missing_link_constraints` - Template-basiert: Links fehlen (aggregiert)
- `weak_chain_roles` - Template-basiert: Nur non-causal Rollen (aggregiert)
**Warum aktuell nicht verwendet?**
- Die Workbench fokussiert sich aktuell nur auf **Template-basierte Todos**
- Findings sind teilweise **aggregiert** (z.B. "missing_slot_trigger" für alle Matches)
- Workbench benötigt **granulare Todos** pro Match (z.B. "missing_slot_trigger" für jeden Match einzeln)
- Workbench benötigt **konkrete Actions** (z.B. `insert_edge_forward`, `create_note_via_interview`)
**Sollten integriert werden:**
Die Findings könnten als **zusätzliche Todos** integriert werden:
- `dangling_target` → Todo mit Action `create_missing_note` oder `retarget_link`
- `dangling_target_heading` → Todo mit Action `create_missing_heading` oder `retarget_to_existing_heading`
- `only_candidates` → Todo mit Action `promote_all_candidates` oder `create_explicit_edges`
- `missing_edges` → Todo mit Action `add_edges_to_section`
- `no_causal_roles` → Todo ähnlich wie `weak_roles`, aber section-weit (nicht template-basiert)
- `one_sided_connectivity` → Informatives Todo (keine Action, nur Hinweis)
**Vorteil der Integration:**
- Nutzung der **getesteten Heuristiken** aus 0.4.x
- **Vollständigere Analyse** (nicht nur Template-basiert)
- **Konsistenz** zwischen Chain Inspector und Workbench
---
## Neue Analysen in 0.5.x
### 1. Status-Berechnung (`statusCalculator.ts`)
**Neu in 0.5.x:** Berechnet `MatchStatus` basierend auf Slot/Link-Erfüllung:
- **`complete`**: `slotsFilled == slotsTotal && linksSatisfied == linksRequired`
- **`near_complete`**:
- `slotsFilled == slotsTotal && (linksRequired - linksSatisfied) in {1,2}`
- ODER `(slotsTotal - slotsFilled) == 1 && linksSatisfied == linksRequired`
- **`weak`**: Match vorhanden, aber nur structural/temporal Rollen (keine causal)
- **`partial`**: Sonstige Fälle mit mindestens einer Lücke
**Basis:** TemplateMatch aus 0.4.x, aber **neue Heuristik** für Status-Kategorisierung.
### 2. Granulare Todo-Generierung (`todoGenerator.ts`)
**Neu in 0.5.x:** Generiert konkrete Todos pro Match:
#### `missing_slot` Todo
- **Basis:** `match.missingSlots` aus TemplateMatch
- **Erweiterung:**
- Pro Slot ein Todo (nicht aggregiert)
- Enthält `allowedNodeTypes` für Interview-Filterung
- Enthält Actions: `["link_existing", "create_note_via_interview"]`
#### `missing_link` Todo
- **Basis:** Template-Links aus `template.links` + `match.slotAssignments`
- **Erweiterung:**
- Prüft, ob beide Slots gefüllt sind, aber Link fehlt
- Enthält `fromNodeRef` und `toNodeRef` (konkrete Referenzen)
- Enthält `suggestedEdgeTypes` aus `chain_roles.yaml`
- Enthält Actions: `["insert_edge_forward", "insert_edge_inverse", "choose_target_anchor"]`
#### `weak_roles` Todo
- **Basis:** `match.roleEvidence` aus TemplateMatch
- **Erweiterung:**
- Prüft, ob alle Rollen structural/temporal sind (keine causal)
- Enthält Liste von `edges` mit `currentRole` und `suggestedRoles`
- Enthält Actions: `["change_edge_type"]`
#### `candidate_cleanup` Todo (NEU)
- **Basis:** Candidate-Edges aus `graphIndex` + `missing_link` Todos
- **Vollständig neu:**
- Findet Candidate-Edges, die zu `missing_link` Requirements passen
- **Relation-Equality-Check:** Prüft, ob bereits ein confirmed Edge für dieselbe Relation existiert
- Wenn ja → kein Todo (verhindert Duplikate)
- Wenn nein → Todo mit `promote_candidate` Action
**Relation-Equality-Logik:**
```typescript
// Prüft:
// 1. Direction match (from → to)
// 2. Node-Refs match (file + heading)
// 3. Canonical Edge-Type match (via edge_vocabulary.md)
```
### 3. Effective Required Links Resolution
**Neu in 0.5.x:** Resolved `required_links` Flag mit Priorität:
1. `template.matching?.required_links` (höchste Priorität)
2. `profile.required_links`
3. `defaults.matching?.required_links`
4. Fallback: `false`
**Basis:** TemplateMatch nutzt bereits `requiredLinks`, aber Workbench benötigt explizite Resolution für UI-Darstellung.
---
## Vergleich: Findings vs. Todos
| Aspekt | Chain Inspector 0.4.x (Findings) | Chain Workbench 0.5.x (Todos) |
|--------|----------------------------------|-------------------------------|
| **Granularität** | Aggregiert (pro Template-Typ) | Granular (pro Match, pro Slot/Link) |
| **Format** | `Finding` Interface (code, severity, message) | `WorkbenchTodoUnion` Interface (type, actions, refs) |
| **Actions** | Keine (nur Informativ) | Konkrete Actions (`insert_edge_forward`, etc.) |
| **Basis** | Template Matches + Gap-Heuristiken | Template Matches + zusätzliche Analysen |
| **Verwendung** | Console-Output, Fix Findings Command | Workbench UI, interaktive Bearbeitung |
---
## Abhängigkeiten
### Direkte Abhängigkeiten (0.4.x)
1. **`TemplateMatch`** aus `chainInspector.ts`
- Wird direkt verwendet für Status-Berechnung und Todo-Generierung
2. **`ChainTemplatesConfig`** aus `dictionary/types.ts`
- Wird verwendet für Slot/Link-Definitionen und `allowed_node_types`
3. **`ChainRolesConfig`** aus `dictionary/types.ts`
- Wird verwendet für `suggestedEdgeTypes` in `missing_link` Todos
4. **`EdgeVocabulary`** aus `vocab/types.ts`
- Wird verwendet für Canonical-Type-Resolution (Relation-Equality)
5. **`IndexedEdge[]`** aus `graphIndex.ts`
- Wird verwendet für Candidate/Confirmed-Edge-Trennung
### Indirekte Abhängigkeiten
1. **Template Matching Algorithmus** (0.4.x)
- Backtracking-Algorithmus für Slot-Assignment
- Scoring-Mechanismus (+10 pro Link, +2 pro Slot, -5 pro fehlendem required Link)
2. **Edge-Role-Mapping** (0.4.x)
- `chain_roles.yaml` → Edge-Types → Roles
- Wird verwendet für `weak_roles` Detection
---
## Neue Heuristiken (nicht in 0.4.x)
### 1. Relation-Equality-Check
**Zweck:** Verhindert Duplikate bei Candidate-Cleanup.
**Logik:**
- Prüft, ob bereits ein confirmed Edge für dieselbe Relation existiert
- Relation = (fromNodeRef, toNodeRef, canonicalEdgeType)
- Wenn ja → kein `candidate_cleanup` Todo
**Implementierung:** `todoGenerator.ts` → `checkRelationExists()`
### 2. Status-Kategorisierung
**Zweck:** Priorisierung von Matches in Workbench UI.
**Logik:**
- `complete` → höchste Priorität (grün)
- `near_complete` → hohe Priorität (gelb)
- `partial` → mittlere Priorität (orange)
- `weak` → niedrige Priorität (rot)
**Implementierung:** `statusCalculator.ts` → `calculateMatchStatus()`
### 3. Effective Required Links Resolution
**Zweck:** Korrekte Darstellung von Link-Requirements in UI.
**Logik:**
- Resolved `required_links` Flag mit Priorität (template > profile > defaults)
- Beeinflusst, ob `missing_link` Todos generiert werden
**Implementierung:** `statusCalculator.ts` → `getEffectiveRequiredLinks()`
---
## Zusammenfassung
### Basierend auf 0.4.x
✅ **Template Matches** - Direkt verwendet
✅ **Slot-Assignments** - Direkt verwendet
✅ **Missing Slots** - Direkt verwendet
✅ **Role Evidence** - Direkt verwendet
✅ **Edge-Role-Mapping** - Direkt verwendet
✅ **Canonical Edge Types** - Direkt verwendet
### Neu in 0.5.x
🆕 **Status-Berechnung** - Neue Heuristik
🆕 **Granulare Todos** - Pro Match, pro Slot/Link
🆕 **Candidate-Cleanup** - Relation-Equality-Check
🆕 **Effective Required Links** - Prioritäts-Resolution
🆕 **Action-System** - Konkrete Actions pro Todo
### Nicht verwendet aus 0.4.x (sollten integriert werden)
⚠️ **Findings** - Werden aktuell nicht verwendet, sollten aber integriert werden
⚠️ **Gap-Heuristiken** - Werden aktuell nicht verwendet, sollten aber integriert werden
⚠️ **Dangling Target Checks** - Werden aktuell nicht verwendet, sollten aber integriert werden
**Empfehlung:** Die Findings sollten als **zusätzliche Todos** in die Workbench integriert werden, um die getesteten Heuristiken zu nutzen und eine vollständigere Analyse zu bieten.
---
## Fazit
Die Chain Workbench (0.5.x) basiert **hauptsächlich** auf den Template Matches aus Chain Inspector (0.4.x), erweitert diese aber um:
1. **Granulare Todo-Generierung** (pro Match, pro Slot/Link)
2. **Status-Kategorisierung** (complete, near_complete, partial, weak)
3. **Candidate-Cleanup-Heuristik** (Relation-Equality-Check)
4. **Action-System** (konkrete Actions pro Todo)
**Aktueller Stand:**
Die Workbench verwendet aktuell **nur** die Template Matches aus 0.4.x, nicht die Findings. Dies ermöglicht eine **interaktive Bearbeitung** mit konkreten Actions.
**Empfohlene Erweiterung:**
Die Findings aus 0.4.x sollten als **zusätzliche Todos** integriert werden, um:
- Die **getesteten Heuristiken** zu nutzen
- Eine **vollständigere Analyse** zu bieten (nicht nur Template-basiert)
- **Konsistenz** zwischen Chain Inspector und Workbench zu gewährleisten
**Nächste Schritte:**
1. Findings aus `report.findings` in `buildWorkbenchModel` einlesen
2. Findings zu Todos konvertieren (mit entsprechenden Actions)
3. Findings-Todos zu den Template-basierten Todos hinzufügen
4. UI erweitern, um beide Todo-Typen anzuzeigen
---
**Letzte Aktualisierung:** 2025-01-XX
**Version:** 0.5.x
+342
View File
@@ -0,0 +1,342 @@
# Chain Workbench - Findings Integration (Vorschlag)
> **Status:** Vorschlag für zukünftige Implementierung
> **Stand:** 2025-01-XX
> **Zielgruppe:** Entwickler
---
## Problemstellung
Die Chain Workbench (0.5.x) verwendet aktuell **nur** Template Matches aus Chain Inspector (0.4.x), nicht aber die **Findings** und **Gap-Heuristiken**, die aufwendig getestet wurden.
**Verlorene Informationen:**
- `dangling_target` - Target-Datei existiert nicht
- `dangling_target_heading` - Target-Heading existiert nicht
- `only_candidates` - Nur Candidate-Edges, keine expliziten
- `missing_edges` - Section hat Content aber keine Edges
- `no_causal_roles` - Section hat Edges aber keine kausalen Rollen
- `one_sided_connectivity` - Nur incoming oder nur outgoing edges
---
## Lösungsvorschlag
### 1. Findings zu Todos konvertieren
Erweitere `todoGenerator.ts` um eine Funktion `generateFindingsTodos()`:
```typescript
/**
* Generate todos from Chain Inspector findings.
*/
export function generateFindingsTodos(
findings: Finding[],
allEdges: IndexedEdge[],
context: { file: string; heading: string | null }
): WorkbenchTodoUnion[] {
const todos: WorkbenchTodoUnion[] = [];
for (const finding of findings) {
switch (finding.code) {
case "dangling_target":
// Find edge with dangling target
const danglingEdge = allEdges.find(
(e) => e.target.file === finding.evidence?.file
);
if (danglingEdge) {
todos.push({
type: "dangling_target",
id: `dangling_target_${finding.evidence?.file}`,
description: finding.message,
priority: finding.severity === "error" ? "high" : "medium",
targetFile: danglingEdge.target.file,
targetHeading: danglingEdge.target.heading,
sourceEdge: {
file: "sectionHeading" in danglingEdge.source
? danglingEdge.source.file
: danglingEdge.source.file,
heading: "sectionHeading" in danglingEdge.source
? danglingEdge.source.sectionHeading
: null,
},
actions: ["create_missing_note", "retarget_link"],
});
}
break;
case "dangling_target_heading":
// Similar to dangling_target, but for headings
todos.push({
type: "dangling_target_heading",
id: `dangling_target_heading_${finding.evidence?.file}_${finding.evidence?.sectionHeading}`,
description: finding.message,
priority: finding.severity === "warn" ? "medium" : "low",
targetFile: finding.evidence?.file || "",
targetHeading: finding.evidence?.sectionHeading || null,
actions: ["create_missing_heading", "retarget_to_existing_heading"],
});
break;
case "only_candidates":
// Find all candidate edges in section
const candidateEdges = allEdges.filter(
(e) => e.scope === "candidate" &&
("sectionHeading" in e.source
? e.source.sectionHeading === context.heading
: false)
);
if (candidateEdges.length > 0) {
todos.push({
type: "only_candidates",
id: `only_candidates_${context.file}_${context.heading}`,
description: finding.message,
priority: "medium",
candidateEdges: candidateEdges.map((e) => ({
rawEdgeType: e.rawEdgeType,
from: "sectionHeading" in e.source
? { file: e.source.file, heading: e.source.sectionHeading }
: { file: e.source.file, heading: null },
to: e.target,
})),
actions: ["promote_all_candidates", "create_explicit_edges"],
});
}
break;
case "missing_edges":
todos.push({
type: "missing_edges",
id: `missing_edges_${context.file}_${context.heading}`,
description: finding.message,
priority: "medium",
section: {
file: context.file,
heading: context.heading,
},
actions: ["add_edges_to_section"],
});
break;
case "no_causal_roles":
// Find edges without causal roles
const nonCausalEdges = allEdges.filter(
(e) => e.scope === "section" &&
("sectionHeading" in e.source
? e.source.sectionHeading === context.heading
: false)
);
todos.push({
type: "no_causal_roles",
id: `no_causal_roles_${context.file}_${context.heading}`,
description: finding.message,
priority: "medium",
edges: nonCausalEdges.map((e) => ({
rawEdgeType: e.rawEdgeType,
from: "sectionHeading" in e.source
? { file: e.source.file, heading: e.source.sectionHeading }
: { file: e.source.file, heading: null },
to: e.target,
currentRole: null, // Would need to resolve via chain_roles
suggestedRoles: ["causal", "influences", "enables_constraints"],
})),
actions: ["change_edge_type"],
});
break;
case "one_sided_connectivity":
// Informational only
todos.push({
type: "one_sided_connectivity",
id: `one_sided_connectivity_${context.file}_${context.heading}`,
description: finding.message,
priority: "low",
section: {
file: context.file,
heading: context.heading,
},
actions: [], // No actions, informational only
});
break;
}
}
return todos;
}
```
### 2. Erweitere Todo-Types
Füge neue Todo-Types zu `types.ts` hinzu:
```typescript
export type TodoType =
| "missing_slot"
| "missing_link"
| "weak_roles"
| "candidate_cleanup"
| "create_candidates_zone"
| "create_note_links_zone"
| "dangling_target" // NEU
| "dangling_target_heading" // NEU
| "only_candidates" // NEU
| "missing_edges" // NEU
| "no_causal_roles" // NEU
| "one_sided_connectivity"; // NEU
export interface DanglingTargetTodo extends WorkbenchTodo {
type: "dangling_target";
targetFile: string;
targetHeading: string | null;
sourceEdge: {
file: string;
heading: string | null;
};
actions: Array<"create_missing_note" | "retarget_link">;
}
export interface DanglingTargetHeadingTodo extends WorkbenchTodo {
type: "dangling_target_heading";
targetFile: string;
targetHeading: string | null;
actions: Array<"create_missing_heading" | "retarget_to_existing_heading">;
}
export interface OnlyCandidatesTodo extends WorkbenchTodo {
type: "only_candidates";
candidateEdges: Array<{
rawEdgeType: string;
from: { file: string; heading: string | null };
to: { file: string; heading: string | null };
}>;
actions: Array<"promote_all_candidates" | "create_explicit_edges">;
}
export interface MissingEdgesTodo extends WorkbenchTodo {
type: "missing_edges";
section: {
file: string;
heading: string | null;
};
actions: Array<"add_edges_to_section">;
}
export interface NoCausalRolesTodo extends WorkbenchTodo {
type: "no_causal_roles";
edges: Array<{
rawEdgeType: string;
from: { file: string; heading: string | null };
to: { file: string; heading: string | null };
currentRole: string | null;
suggestedRoles: string[];
}>;
actions: Array<"change_edge_type">;
}
export interface OneSidedConnectivityTodo extends WorkbenchTodo {
type: "one_sided_connectivity";
section: {
file: string;
heading: string | null;
};
actions: []; // Informational only
}
```
### 3. Integriere Findings in Workbench Builder
Erweitere `workbenchBuilder.ts`:
```typescript
export async function buildWorkbenchModel(
app: App,
report: ChainInspectorReport,
chainTemplates: ChainTemplatesConfig | null,
chainRoles: ChainRolesConfig | null,
edgeVocabulary: EdgeVocabulary | null,
allEdges: IndexedEdge[]
): Promise<WorkbenchModel> {
const matches: WorkbenchMatch[] = [];
const globalTodos: WorkbenchTodoUnion[] = []; // NEU: Global todos from findings
// ... existing template match processing ...
// NEU: Generate todos from findings
if (report.findings && report.findings.length > 0) {
const findingsTodos = generateFindingsTodos(
report.findings,
allEdges,
report.context
);
globalTodos.push(...findingsTodos);
}
return {
context: report.context,
matches,
globalTodos, // NEU: Add global todos
timestamp: Date.now(),
};
}
```
### 4. Erweitere WorkbenchModel Interface
```typescript
export interface WorkbenchModel {
context: {
file: string;
heading: string | null;
zoneKind: string;
};
matches: WorkbenchMatch[];
globalTodos?: WorkbenchTodoUnion[]; // NEU: Todos from findings (not template-based)
timestamp: number;
}
```
### 5. UI-Integration
Erweitere `ChainWorkbenchModal.ts`:
```typescript
// Show global todos (from findings) separately
if (model.globalTodos && model.globalTodos.length > 0) {
// Render "Section-Level Issues" section
// Show findings-based todos before template matches
}
```
---
## Vorteile
1. **Nutzt getestete Heuristiken** - Findings aus 0.4.x werden verwendet
2. **Vollständigere Analyse** - Nicht nur Template-basiert, sondern auch Section-Level
3. **Konsistenz** - Chain Inspector und Workbench zeigen dieselben Probleme
4. **Bessere UX** - User sieht alle Probleme auf einen Blick
---
## Implementierungsreihenfolge
1. **Phase 1:** Todo-Types erweitern (`types.ts`)
2. **Phase 2:** `generateFindingsTodos()` implementieren (`todoGenerator.ts`)
3. **Phase 3:** `buildWorkbenchModel()` erweitern (`workbenchBuilder.ts`)
4. **Phase 4:** UI erweitern (`ChainWorkbenchModal.ts`)
5. **Phase 5:** Actions implementieren (z.B. `create_missing_note`, `retarget_link`)
---
## Offene Fragen
1. **Priorität:** Sollen Findings-Todos höhere Priorität haben als Template-Todos?
2. **Duplikate:** Wie vermeiden wir Duplikate zwischen Findings-Todos und Template-Todos?
- Beispiel: `dangling_target` könnte auch als `missing_link` Todo erscheinen
3. **Filterung:** Sollen Findings-Todos gefiltert werden können (z.B. nur Errors)?
4. **Actions:** Welche Actions sind für welche Findings sinnvoll?
---
**Letzte Aktualisierung:** 2025-01-XX
**Status:** Vorschlag für zukünftige Implementierung
+10
View File
@@ -106,6 +106,7 @@ Diese Dokumentation deckt alle Aspekte des **Mindnet Causal Assistant** Plugins
### Konzepte & Details
- [02_causal_chain_retrieving.md](./02_causal_chain_retrieving.md) - Kausale Ketten-Retrieval
- [02_concepts/03_chain_identification_and_matching.md](./02_concepts/03_chain_identification_and_matching.md) - **Chain-Identifikation und Template Matching** - Vollständige Erklärung des Prozesses, wie Chains identifiziert und gefüllt werden
- [DANGLING_TARGET_CASES.md](./DANGLING_TARGET_CASES.md) - Dangling Target Findings
- [06_Konfigurationsdateien_Referenz.md](./06_Konfigurationsdateien_Referenz.md) - Vollständige Referenz aller Config-Dateien
- [07_Event_Handler_Commands.md](./07_Event_Handler_Commands.md) - Event Handler & Commands Referenz
@@ -114,6 +115,15 @@ Diese Dokumentation deckt alle Aspekte des **Mindnet Causal Assistant** Plugins
- [00_Dokumentations_Index.md](./00_Dokumentations_Index.md) - Vollständige Übersicht aller Dokumentationen
### Testing
- [08_Testing_Chain_Workbench.md](./08_Testing_Chain_Workbench.md) - Anleitung zum Testen der Chain Workbench und Vault Triage Features (0.5.x)
### Architektur & Analyse-Basis
- [09_Workbench_Analysis_Basis.md](./09_Workbench_Analysis_Basis.md) - Analyse-Basis der Chain Workbench (0.5.x) und Abhängigkeiten zu Chain Inspector (0.4.x)
- [10_Workbench_Findings_Integration.md](./10_Workbench_Findings_Integration.md) - Vorschlag zur Integration der Findings aus 0.4.x in die Workbench
### Legacy-Dokumentation
- [readme.md](./readme.md) - MVP 1.0 Quickstart