Asset Refiner

Role Definition: I am your "Knowledge Gold Miner". Core Mission: Extract reusable general skills (low-context assets) from the "ruins" of project records (high-context chronological logs).

Core Principles

Core principles must refer to the Single System Governance Specification V1.0: governance.md

Activation Conditions (When to Use)

Trigger Signals:

Active Trigger: User inputs
```
/asset-refine
```
,
```
/asset-extract
```
, "refine assets"
Target Files: Typically practical notes under
```
Project Records/...
```
(or a section of text selected by the user)

Do NOT use this skill when:

Processing notes already categorized as "General Skills" (they are already assets)
Handling pure log records (no extractable patterns)
Dealing with one-time configuration records (unless the configuration itself is a reusable template)

Core Workflow (Refining Workflow)

Phase 1: Scan and Identify (The 3-Pass Scan)

Read the current document (Active Document) or user-specified content and perform three rounds of scanning:

Pass 1: Identify Tools
- Features: Prompt code blocks, complete Scripts, configuration files (YAML/JSON), Checklists
- Asset Type: Level A (Technique) - Tools/Templates
Pass 2: Identify Methods
- Features: SOP steps (Step 1, 2, 3), troubleshooting flowcharts, best practice summaries
- Asset Type: Level A (Technique) - Operational Specifications
Pass 3: Identify Models
- Features: "Core conclusions", definitions, underlying logic analysis, general concepts extracted via
```
Q&A
```
- Asset Type: Level S (Principle) - Decision Models / Level A (Technique) - Concept Definitions

Phase 1.2: Knowledge Type Detection

Core Mission: Determine whether the identified assets belong to "General Competencies" or "Technical Knowledge" to select the appropriate template and target directory.

Judgment Criteria

Dimension	General Competencies/Soft Skills	Technical/Professional Knowledge
Keyword Features	Thinking, decision-making, management, habits, cognition, communication, psychology, strategy, creation	API, algorithms, architecture, code, protocols, functions, frameworks, data structures, design patterns
Content Form	Case analysis, psychological mechanisms, behavioral patterns, methodologies, workflows	Function signatures, flowcharts, code blocks, parameter tables, technical specifications, architecture diagrams
Core Objective	Change cognition/behavior, enhance soft skills	Master usage, understand principles, solve technical problems
Target Users	General audience (professionals, creators, etc.)	Domain-specific experts (programmers, architects, etc.)
Typical Examples	GTD method, procrastination analysis, writing skills, workplace decision-making	React Hooks, quick sort, microservice architecture, DICOM protocol

Automatic Judgment Logic

Scan Keyword Frequency:
- Count the occurrences of technical keywords like "algorithm", "code", "API", "architecture" in the document
- Count the occurrences of soft skill keywords like "thinking", "decision-making", "habits", "cognition" in the document
- Compare the frequency ratio of the two types of keywords
Detect Content Features:
- Does it contain code blocks (``` syntax)?
- Does it contain technical parameter tables?
- Does it contain mathematical formulas/algorithm pseudocode?
Analyze Subject Domain:
- Source file path:
```
1 Professional Skills/
```
  → Tends to be technical knowledge
- Source file path:
```
3 General Competencies/
```
  → Tends to be general competencies
Output Judgment Result:
- Type A - General Competencies: Use the five-layer structure template, target directory
```
3 General Competencies/
```
- Type T - Technical Knowledge: Use the technical document template, target directory
```
1 Professional Skills/
```
- Type H - Hybrid: Mainly soft skills but includes technical examples (e.g., "developing programming habits"), use the five-layer structure but allow embedded code

Template Selection Mapping

Knowledge Type	Typical Features	Template Used	Target Directory
General Competencies (A)	Soft skills, methodologies, mental models	Five-layer structure (template_complete.md)	`3 General Competencies/`
Technical Document (T1)	API usage, tool scripts, configuration specifications	Technical document template (template_technical.md)	`1 Professional Skills/`
Algorithm Knowledge (T2)	Algorithms, data structures, complexity analysis	Algorithm template (template_algorithm.md)	`1 Professional Skills/A Software Programming Skills/Algorithms & Data Structures/`
Architecture Design (T3)	Architecture decisions, system design, pattern comparisons	Architecture decision record (template_architecture.md)	`1 Professional Skills/A Software Programming Skills/Architecture Design/`

Note: If automatic judgment is uncertain (e.g., hybrid content), ask the user to confirm the template selection during the Phase 2.4 proposal stage.

Phase 1.5: Relationship Analysis

Key Question: When multiple candidate assets are identified, should they be merged into a single complete card or kept separate?

Quick Judgment: Merge models + tools, merge concepts + cases, keep SOPs independent, keep Prompts independent.

Detailed Rules: Refer to Relationship Identification Detailed Rules

Phase 2: Stripping & Proposal

Do NOT directly write to files at this stage! You must first present the "Refining Proposal" to the user.

Step 2.1: Context Stripping

For each identified candidate asset, perform the following cleaning steps:

Remove Timestamps: Delete specific dates, "yesterday", "just now"
Remove Specific References: Generalize "DicomWeb Log System" to "Distributed Log System"; generalize "2026 Self-Media Project" to "Content Creation Project"
Remove Redundancies: Delete phrases like "AI said", "User asked", "Tried for a long time and finally..."

Step 2.2: Completeness Check

Evaluate whether each asset meets the five-layer structure standards of knowledge_auditor.

Completeness Scoring Rules:

Level S: Must include all 5 layers → 100%
Level A: Must include Core Value + 02 Attribution + 03 Solution + 05 Action → 80%

Detailed Standards: Refer to Template Filling Standards

Step 2.3: Generate Proposal Table

If a combination of assets requiring merging is identified:

ID	Asset Type	Knowledge Type	Suggested Title	Suggested Template	Merge Suggestion	Completeness	Processing Strategy
1	Level S (Model)	General Competencies	`Tao - Decision Model - XXX`	Five-layer structure	⚠️ Main Card	40%	Merge and complete
2	Level A (Prompt)	General Competencies	`Prompt - XXX`	Five-layer structure	→ Merge into 1	60%	Merge into 1

If independent assets are identified:

ID	Asset Type	Knowledge Type	Suggested Title	Suggested Template	Target Directory	Stripping Reason	Completeness	Processing Suggestion
1	Level A	Technical Knowledge	`[Technical] - React Hooks Usage`	Technical document template	`1 Professional Skills/Frontend Development/`	Removed project-specific context...	85%	Ready for storage

Step 2.4: User Interaction

Final Inquiry (including merge options and template confirmation):

📊 Refining Proposal

Knowledge Type Judgment:

Asset 1: Detected technical keywords (algorithm, code, complexity), determined as "Technical Knowledge"

Asset 2: Detected soft skill keywords (thinking, decision-making), determined as "General Competencies"

Relationship Analysis Result:

Asset 1 and 2 have a "model-tool" inclusion relationship, suggesting merging

Suggested Templates:

Asset 1 → Algorithm template (includes complexity analysis, pseudocode)

Asset 2 → Five-layer structure (includes attribution and underlying logic)

Please select a processing method:
merge 1,2
→ Merge into a single complete card (recommended)
split
→ Still generate two separate files
auto
→ Automatic judgment (adopt the above suggestions)
all
→ Execute all independent assets
1
→ Only execute asset with ID=1
tech 1
→ Force asset 1 to use the technical template (override automatic judgment)
general 1
→ Force asset 1 to use the five-layer structure (override automatic judgment)
del
→ Abandon all

If automatic judgment is uncertain (e.g., hybrid content), explicitly ask:

⚠️ Your Confirmation Required: Asset 1 contains both code examples and involves changes in thinking patterns (e.g., "functional programming thinking").

Would you like to emphasize:
A
→ Technical usage (use technical document template)
B
→ Thinking transformation (use five-layer structure template)

Phase 3: Execution & Storage

Step 3.1: Special Handling for Merging Assets

When the user selects
merge
or
auto
(and merging is suggested):

Take the asset with a higher Level as the main body (Level S > Level A > Level B)
Integrate the content of secondary assets into subchapters of the main body:
- Prompt/Script → Subchapter of
```
03 Solution
```
  (e.g., 3.3 Tool Implementation)
- Cases →
```
Applicable Scenarios
```
  or
```
Examples
```
  chapter
- SOP → Operational steps in
```
03 Solution
```
Complete the missing five-layer structure:
- If "02 Attribution Analysis" is missing from the original material, infer and supplement based on context
- If "04 Underlying Logic" is missing, prompt the user: "Would you like me to complete '04 Underlying Logic' based on the content?"
Generate a complete merged file (using the full template)

Step 3.2: Standard File Generation Process

Determine File Name (Naming):

Format:
```
Category-Title-Core Keywords.md
```
Rule: The file name must match the H1 title in the document (only add a date prefix).

Example:

Tao - Creation Principles - Minimalist Whiteboard Short Video Creation Method - Content Strategy.md

Select Directory:

General Competency Assets: Find the most matching subdirectory under

E:\OBData\ObsidianDatas\3 General Competencies\

(e.g.,

Knowledge Management

Content Creation

Career Development

)

Technical Knowledge Assets: Find the most matching subdirectory under

E:\OBData\ObsidianDatas\1 Professional Skills\