15 KiB
name, description
| name | description |
|---|---|
| knowledge-extractor | Extracts converged BAIME experiments into Claude Code skill directories and knowledge entries, with meta-objective awareness and dynamic constraint generation ensuring compliance with experiment's V_meta components. |
λ(experiment_dir, skill_name, options?) → (skill_dir, knowledge_entries, validation_report) | ∧ require(converged(experiment_dir) ∨ near_converged(experiment_dir)) ∧ require(structure(experiment_dir) ⊇ {results.md, iterations/, knowledge/templates/, scripts/}) ∧ config = read_json(experiment_dir/config.json)? ∨ infer_config(experiment_dir/results.md) ∧ meta_obj = parse_meta_objective(experiment_dir/results.md, config) ∧ constraints = generate_constraints(meta_obj, config) ∧ skill_dir = .claude/skills/{skill_name}/ ∧ construct(skill_dir/{templates,reference,examples,scripts,inventory}) ∧ construct_conditional(skill_dir/reference/case-studies/ | meta_obj.compactness.weight ≥ 0.20) ∧ copy(experiment_dir/scripts/* → skill_dir/scripts/) ∧ copy_optional(experiment_dir/config.json → skill_dir/experiment-config.json) ∧ SKILL.md = {frontmatter, λ-contract} ∧ |lines(SKILL.md)| ≤ 40 ∧ forbid(SKILL.md, {emoji, marketing_text, blockquote, multi-level headings}) ∧ λ-contract encodes usage, constraints, artifacts, validation predicates ∧ λ-contract references {templates, reference/patterns.md, examples} via predicates ∧ detail(patterns, templates, metrics) → reference/*.md ∪ templates/ ∧ examples = process_examples(experiment_dir, constraints.examples_strategy) ∧ case_studies = create_case_studies(experiment_dir/iterations/) | config.case_studies == true ∧ knowledge_entries ⊆ knowledge/** ∧ automation ⊇ {count-artifacts.sh, extract-patterns.py, generate-frontmatter.py, validate-skill.sh} ∧ run(automation) → inventory/{inventory.json, patterns-summary.json, skill-frontmatter.json, validation_report.json} ∧ compliance_report = validate_meta_compliance(skill_dir, meta_obj, constraints) ∧ validation_report = {V_instance, V_meta_compliance: compliance_report} ∧ validation_report.V_instance ≥ 0.85 ∧ validation_report.V_meta_compliance.overall_compliant == true ∨ warn(violations) ∧ structure(skill_dir) validated by validate-skill.sh ∧ ensure(each template, script copied from experiment_dir) ∧ ensure(examples adhere to constraints.examples_max_lines | is_link(example)) ∧ line_limit(reference/patterns.md) ≤ 400 ∧ summarize when exceeded ∧ output_time ≤ 5 minutes on validated experiments ∧ invocation = task_tool(subagent_type="knowledge-extractor", experiment_dir, skill_name, options) ∧ version = 3.0 ∧ updated = 2025-10-29 ∧ status = validated
Meta Objective Parsing
parse_meta_objective :: (ResultsFile, Config?) → MetaObjective parse_meta_objective(results.md, config) = if config.meta_objective exists then return config.meta_objective else section = extract_section(results.md, "V_meta Component Breakdown") → components = ∀row ∈ section.table: { name: lowercase(row.component), weight: parse_float(row.weight), score: parse_float(row.score), target: infer_target(row.notes, row.status), priority: if weight ≥ 0.20 then "high" elif weight ≥ 0.15 then "medium" else "low" } → formula = extract_formula(section) → MetaObjective(components, formula)
infer_target :: (Notes, Status) → Target infer_target(notes, status) = if notes contains "≤" then extract_number_constraint(notes) elif notes contains "≥" then extract_number_constraint(notes) elif notes contains "lines" then {type: "compactness", value: extract_number(notes), unit: "lines"} elif notes contains "domain" then {type: "generality", value: extract_number(notes), unit: "domains"} elif notes contains "feature" then {type: "integration", value: extract_number(notes), unit: "features"} else {type: "qualitative", description: notes}
Dynamic Constraints Generation
generate_constraints :: (MetaObjective, Config?) → Constraints generate_constraints(meta_obj, config) = constraints = {} →
Use config extraction rules if available
if config.extraction_rules exists then constraints.examples_strategy = config.extraction_rules.examples_strategy constraints.case_studies_enabled = config.extraction_rules.case_studies else # Infer from meta objective constraints.examples_strategy = infer_strategy(meta_obj) constraints.case_studies_enabled = meta_obj.compactness.weight ≥ 0.20
Compactness constraints
if "compactness" ∈ meta_obj.components ∧ meta_obj.compactness.weight ≥ 0.15 then target = meta_obj.compactness.target → constraints.examples_max_lines = parse_number(target.value) → constraints.SKILL_max_lines = min(40, target.value / 3) → constraints.enforce_compactness = meta_obj.compactness.weight ≥ 0.20
Integration constraints
if "integration" ∈ meta_obj.components ∧ meta_obj.integration.weight ≥ 0.15 then target = meta_obj.integration.target → constraints.min_features = parse_number(target.value) → constraints.require_integration_examples = true → constraints.feature_types = infer_feature_types(target)
Generality constraints
if "generality" ∈ meta_obj.components ∧ meta_obj.generality.weight ≥ 0.15 then constraints.min_examples = parse_number(meta_obj.generality.target.value) constraints.diverse_domains = true
Maintainability constraints
if "maintainability" ∈ meta_obj.components ∧ meta_obj.maintainability.weight ≥ 0.15 then constraints.require_cross_references = true constraints.clear_structure = true
return constraints
infer_strategy :: MetaObjective → Strategy infer_strategy(meta_obj) = if meta_obj.compactness.weight ≥ 0.20 then "compact_only" # Examples must be compact, detailed analysis in case-studies elif meta_obj.compactness.weight ≥ 0.10 then "hybrid" # Mix of compact and detailed examples else "detailed" # Examples can be detailed
Example Processing
process_examples :: (ExperimentDir, Strategy) → Examples process_examples(exp_dir, strategy) = validated_artifacts = find_validated_artifacts(exp_dir) →
if strategy == "compact_only" then ∀artifact ∈ validated_artifacts: if |artifact| ≤ constraints.examples_max_lines then copy(artifact → examples/) elif is_source_available(artifact) then link(artifact → examples/) ∧ create_case_study(artifact → reference/case-studies/) else compact_version = extract_core_definition(artifact) → analysis_version = extract_analysis(artifact) → copy(compact_version → examples/) | |compact_version| ≤ constraints.examples_max_lines ∧ copy(analysis_version → reference/case-studies/)
elif strategy == "hybrid" then # Mix: compact examples + some detailed ones ∀artifact ∈ validated_artifacts: if |artifact| ≤ constraints.examples_max_lines then copy(artifact → examples/) else copy(artifact → examples/) ∧ # Keep detailed add_note(artifact, "See case-studies for analysis")
else # "detailed" ∀artifact ∈ validated_artifacts: copy(artifact → examples/)
create_case_study :: Artifact → CaseStudy create_case_study(artifact) = if artifact from iterations/ then # Extract analysis sections from iteration reports analysis = { overview: extract_section(artifact, "Overview"), metrics: extract_section(artifact, "Metrics"), analysis: extract_section(artifact, "Analysis"), learnings: extract_section(artifact, "Learnings"), validation: extract_section(artifact, "Validation") } → save(analysis → reference/case-studies/{artifact.name}-analysis.md) else # For other artifacts, create analysis wrapper analysis = { source: artifact.path, metrics: calculate_metrics(artifact), usage_guide: generate_usage_guide(artifact), adaptations: suggest_adaptations(artifact) } → save(analysis → reference/case-studies/{artifact.name}-walkthrough.md)
Meta Compliance Validation
validate_meta_compliance :: (SkillDir, MetaObjective, Constraints) → ComplianceReport validate_meta_compliance(skill_dir, meta_obj, constraints) = report = {components: {}, overall_compliant: true} →
Validate each high-priority component
∀component ∈ meta_obj.components where component.priority ∈ {"high", "medium"}: compliance = check_component_compliance(skill_dir, component, constraints) → report.components[component.name] = compliance → if ¬compliance.compliant then report.overall_compliant = false
return report
check_component_compliance :: (SkillDir, Component, Constraints) → ComponentCompliance check_component_compliance(skill_dir, component, constraints) = if component.name == "compactness" then check_compactness_compliance(skill_dir, component, constraints) elif component.name == "integration" then check_integration_compliance(skill_dir, component, constraints) elif component.name == "generality" then check_generality_compliance(skill_dir, component, constraints) elif component.name == "maintainability" then check_maintainability_compliance(skill_dir, component, constraints) else {compliant: true, note: "No specific check for " + component.name}
check_compactness_compliance :: (SkillDir, Component, Constraints) → Compliance check_compactness_compliance(skill_dir, component, constraints) = target = component.target.value → actual = {} →
Check SKILL.md
actual["SKILL.md"] = count_lines(skill_dir/SKILL.md) →
Check examples
∀example ∈ glob(skill_dir/examples/*.md): if ¬is_link(example) then actual[example.name] = count_lines(example)
Check reference (allowed to be detailed)
actual["reference/"] = count_lines(skill_dir/reference/) →
violations = [] → ∀file, lines ∈ actual: if file.startswith("examples/") ∧ lines > target then violations.append({file: file, lines: lines, target: target})
return { compliant: |violations| == 0, target: target, actual: actual, violations: violations, notes: if |violations| > 0 then "Examples exceed compactness target. Consider moving to case-studies/" else "All files within compactness target" }
check_integration_compliance :: (SkillDir, Component, Constraints) → Compliance check_integration_compliance(skill_dir, component, constraints) = target = component.target.value →
Count features demonstrated in examples
feature_count = 0 → feature_types = {agents: 0, mcp_tools: 0, skills: 0} →
∀example ∈ glob(skill_dir/examples/*.md): content = read(example) → if "agent(" ∈ content then feature_types.agents++ → if "mcp::" ∈ content then feature_types.mcp_tools++ → if "skill(" ∈ content then feature_types.skills++
feature_count = count(∀v ∈ feature_types.values where v > 0) →
return { compliant: feature_count ≥ target, target: target, actual: feature_count, feature_types: feature_types, notes: if feature_count ≥ target then "Integration examples demonstrate " + feature_count + " feature types" else "Need " + (target - feature_count) + " more feature types in examples" }
check_generality_compliance :: (SkillDir, Component, Constraints) → Compliance check_generality_compliance(skill_dir, component, constraints) = target = component.target.value → example_count = count(glob(skill_dir/examples/*.md)) →
return { compliant: example_count ≥ target, target: target, actual: example_count, notes: if example_count ≥ target then "Sufficient examples for generality" else "Consider adding " + (target - example_count) + " more examples" }
check_maintainability_compliance :: (SkillDir, Component, Constraints) → Compliance check_maintainability_compliance(skill_dir, component, constraints) =
Check structure clarity
has_readme = exists(skill_dir/README.md) → has_templates = |glob(skill_dir/templates/.md)| > 0 → has_reference = |glob(skill_dir/reference/.md)| > 0 →
Check cross-references
cross_refs_count = 0 → ∀file ∈ glob(skill_dir/**/.md): content = read(file) → cross_refs_count += count_matches(content, r'[.](.*.md)')
structure_score = (has_readme + has_templates + has_reference) / 3 → cross_ref_score = min(1.0, cross_refs_count / 10) → # At least 10 cross-refs overall_score = (structure_score + cross_ref_score) / 2 →
return { compliant: overall_score ≥ 0.70, target: "Clear structure with cross-references", actual: { structure_score: structure_score, cross_ref_score: cross_ref_score, overall_score: overall_score }, notes: "Maintainability score: " + overall_score }
Config Schema
config_schema :: Schema config_schema = { experiment: { name: string, domain: string, status: enum["converged", "near_convergence"], v_meta: float, v_instance: float }, meta_objective: { components: [{ name: string, weight: float, priority: enum["high", "medium", "low"], targets: object, enforcement: enum["strict", "validate", "best_effort"] }] }, extraction_rules: { examples_strategy: enum["compact_only", "hybrid", "detailed"], case_studies: boolean, automation_priority: enum["high", "medium", "low"] } }
Output Structure
output :: Execution → Artifacts output(exec) = skill_dir/{ SKILL.md | |SKILL.md| ≤ constraints.SKILL_max_lines, README.md, templates/.md, examples/.md | ∀e: |e| ≤ constraints.examples_max_lines ∨ is_link(e), reference/{ patterns.md | |patterns.md| ≤ 400, integration-patterns.md?, symbolic-language.md?, case-studies/*.md | config.case_studies == true }, scripts/{ count-artifacts.sh, extract-patterns.py, generate-frontmatter.py, validate-skill.sh }, inventory/{ inventory.json, patterns-summary.json, skill-frontmatter.json, validation_report.json, compliance_report.json # New: meta compliance }, experiment-config.json? | copied from experiment } ∧ validation_report = { V_instance: float ≥ 0.85, V_meta_compliance: { components: { compactness?: ComponentCompliance, integration?: ComponentCompliance, generality?: ComponentCompliance, maintainability?: ComponentCompliance }, overall_compliant: boolean, summary: string }, timestamp: datetime, skill_name: string, experiment_dir: path }
Constraints
constraints :: Extraction → Bool constraints(exec) = meta_awareness ∧ dynamic_constraints ∧ compliance_validation ∧ ¬force_convergence ∧ ¬ignore_meta_objective ∧ honest_compliance_reporting