SYMBOL INDEX (431 symbols across 38 files)

FILE: examples/book-sft-pipeline/scripts/pipeline_example.py
  class Chunk (line 17) | class Chunk:
  class TrainingExample (line 23) | class TrainingExample:
    method to_messages (line 28) | def to_messages(self) -> dict:
  function segment_text (line 41) | def segment_text(text: str, min_words: int = 150, max_words: int = 400) ...
  function build_examples (line 92) | def build_examples(chunk: Chunk, instruction: str, author: str, variants...
  function generate_instruction (line 119) | def generate_instruction(chunk: Chunk, llm_call) -> str:
  function build_tinker_datum (line 137) | def build_tinker_datum(example: dict, tokenizer, renderer):
  function validate_style_transfer (line 163) | def validate_style_transfer(output: str, training_data_path: str) -> dict:

FILE: examples/digital-brain-skill/agents/scripts/content_ideas.py
  function load_jsonl (line 14) | def load_jsonl(filepath):
  function get_top_performing_content (line 32) | def get_top_performing_content():
  function get_recent_bookmarks (line 48) | def get_recent_bookmarks(category=None):
  function get_undeveloped_ideas (line 59) | def get_undeveloped_ideas():
  function generate_suggestions (line 66) | def generate_suggestions(pillar=None, count=5):

FILE: examples/digital-brain-skill/agents/scripts/idea_to_draft.py
  function load_jsonl (line 14) | def load_jsonl(filepath):
  function find_idea (line 32) | def find_idea(idea_id):
  function find_related_bookmarks (line 47) | def find_related_bookmarks(tags, pillar):
  function find_similar_posts (line 63) | def find_similar_posts(pillar):
  function generate_draft_scaffold (line 70) | def generate_draft_scaffold(idea_id):

FILE: examples/digital-brain-skill/agents/scripts/stale_contacts.py
  function load_jsonl (line 21) | def load_jsonl(filepath):
  function days_since (line 39) | def days_since(date_str):
  function find_stale_contacts (line 49) | def find_stale_contacts():
  function generate_report (line 82) | def generate_report():

FILE: examples/digital-brain-skill/agents/scripts/weekly_review.py
  function load_jsonl (line 15) | def load_jsonl(filepath):
  function get_week_range (line 34) | def get_week_range():
  function analyze_content (line 41) | def analyze_content(week_start):
  function analyze_network (line 55) | def analyze_network(week_start):
  function analyze_metrics (line 66) | def analyze_metrics():
  function generate_review (line 73) | def generate_review():

FILE: examples/interleaved-thinking/examples/01_basic_capture.py
  function main (line 20) | def main():

FILE: examples/interleaved-thinking/examples/02_tool_usage.py
  function execute_tool (line 61) | def execute_tool(name: str, input_data: dict) -> str:
  function main (line 107) | def main():

FILE: examples/interleaved-thinking/examples/03_full_optimization.py
  function execute_tool (line 838) | def execute_tool(name: str, input_data: dict) -> str:
  function main (line 1015) | def main():

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/analyzer.py
  class TraceAnalyzer (line 123) | class TraceAnalyzer:
    method __init__ (line 142) | def __init__(
    method analyze (line 162) | def analyze(
    method analyze_batch (line 216) | def analyze_batch(
    method quick_score (line 223) | def quick_score(
    method _format_trace_for_analysis (line 266) | def _format_trace_for_analysis(self, trace: ReasoningTrace) -> str:
    method _format_tool_calls (line 276) | def _format_tool_calls(self, trace: ReasoningTrace) -> str:
    method _get_thinking_excerpts (line 291) | def _get_thinking_excerpts(self, trace: ReasoningTrace, max_chars: int...
    method _parse_analysis_response (line 305) | def _parse_analysis_response(
    method _fallback_parse_analysis (line 367) | def _fallback_parse_analysis(
    method _extract_fallback_score (line 404) | def _extract_fallback_score(self, response_text: str) -> float:
  function format_analysis_report (line 426) | def format_analysis_report(analysis: AnalysisResult) -> str:

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/capture.py
  class TraceCapture (line 23) | class TraceCapture:
    method __init__ (line 42) | def __init__(
    method run (line 62) | def run(
    method _process_response (line 159) | def _process_response(
    method _execute_tool (line 191) | def _execute_tool(
    method run_streaming (line 231) | def run_streaming(
  function format_trace_for_display (line 379) | def format_trace_for_display(trace: ReasoningTrace) -> str:

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/cli.py
  function cmd_capture (line 23) | def cmd_capture(args: argparse.Namespace) -> None:
  function cmd_analyze (line 48) | def cmd_analyze(args: argparse.Namespace) -> None:
  function cmd_optimize (line 82) | def cmd_optimize(args: argparse.Namespace) -> None:
  function cmd_generate_skill (line 127) | def cmd_generate_skill(args: argparse.Namespace) -> None:
  function main (line 172) | def main() -> None:

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/loop.py
  class LoopConfig (line 35) | class LoopConfig:
  class OptimizationLoop (line 58) | class OptimizationLoop:
    method __init__ (line 84) | def __init__(
    method run (line 111) | def run(
    method run_single (line 307) | def run_single(
    method _calculate_score (line 332) | def _calculate_score(
    method _check_convergence (line 349) | def _check_convergence(
    method _print_iteration_summary (line 378) | def _print_iteration_summary(self, iteration: LoopIteration) -> None:
    method _print_final_summary (line 398) | def _print_final_summary(self, result: LoopResult) -> None:
    method _save_iteration_artifacts (line 410) | def _save_iteration_artifacts(self, iteration: LoopIteration, num: int...
    method _save_final_artifacts (line 431) | def _save_final_artifacts(self, result: LoopResult) -> None:
  function run_quick_optimization (line 453) | def run_quick_optimization(

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/models.py
  class PatternType (line 11) | class PatternType(Enum):
  class Severity (line 26) | class Severity(Enum):
  class ThinkingBlock (line 36) | class ThinkingBlock:
  class ToolCall (line 52) | class ToolCall:
  class ReasoningTrace (line 65) | class ReasoningTrace:
    method get_thinking_at_turn (line 84) | def get_thinking_at_turn(self, turn: int) -> ThinkingBlock | None:
    method get_tool_calls_at_turn (line 91) | def get_tool_calls_at_turn(self, turn: int) -> list[ToolCall]:
  class Pattern (line 97) | class Pattern:
  class AnalysisResult (line 110) | class AnalysisResult:
  class PromptDiff (line 134) | class PromptDiff:
  class OptimizationResult (line 144) | class OptimizationResult:
  class LoopIteration (line 161) | class LoopIteration:
  class LoopResult (line 176) | class LoopResult:

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/optimizer.py
  class PromptOptimizer (line 99) | class PromptOptimizer:
    method __init__ (line 120) | def __init__(
    method optimize (line 140) | def optimize(
    method optimize_iterative (line 198) | def optimize_iterative(
    method suggest_tool_improvements (line 247) | def suggest_tool_improvements(
    method _format_patterns (line 304) | def _format_patterns(self, analysis: AnalysisResult) -> str:
    method _format_patterns_for_tools (line 319) | def _format_patterns_for_tools(self, patterns: list) -> str:
    method _parse_optimization_response (line 325) | def _parse_optimization_response(
    method _fallback_extract_prompt (line 372) | def _fallback_extract_prompt(self, response_text: str) -> str | None:
  function format_optimization_report (line 414) | def format_optimization_report(result: OptimizationResult) -> str:

FILE: examples/interleaved-thinking/reasoning_trace_optimizer/skill_generator.py
  function _format_list_to_markdown (line 83) | def _format_list_to_markdown(items: list | str) -> str:
  function _format_numbered_list_to_markdown (line 99) | def _format_numbered_list_to_markdown(items: list | str) -> str:
  function _format_examples_to_markdown (line 115) | def _format_examples_to_markdown(examples: list | str) -> str:
  class SkillGenerator (line 138) | class SkillGenerator:
    method __init__ (line 157) | def __init__(
    method generate (line 177) | def generate(
    method generate_from_analysis (line 253) | def generate_from_analysis(
    method _collect_patterns (line 321) | def _collect_patterns(self, result: LoopResult) -> list[Pattern]:
    method _collect_recommendations (line 335) | def _collect_recommendations(self, result: LoopResult) -> list[str]:
    method _collect_key_changes (line 348) | def _collect_key_changes(self, result: LoopResult) -> list[str]:
    method _generate_skill_content (line 358) | def _generate_skill_content(
    method _save_references (line 442) | def _save_references(
  function generate_skill_from_loop (line 485) | def generate_skill_from_loop(

FILE: examples/interleaved-thinking/tests/test_models.py
  function test_thinking_block_creation (line 19) | def test_thinking_block_creation():
  function test_tool_call_creation (line 31) | def test_tool_call_creation():
  function test_reasoning_trace_creation (line 45) | def test_reasoning_trace_creation():
  function test_pattern_creation (line 73) | def test_pattern_creation():
  function test_analysis_result_creation (line 89) | def test_analysis_result_creation():
  function test_optimization_result_creation (line 97) | def test_optimization_result_creation():
  function test_loop_result_creation (line 113) | def test_loop_result_creation():
  function test_pattern_types (line 121) | def test_pattern_types():
  function test_severity_levels (line 139) | def test_severity_levels():

FILE: examples/llm-as-judge-skills/examples/basic-evaluation.ts
  function main (line 13) | async function main() {

FILE: examples/llm-as-judge-skills/examples/full-evaluation-workflow.ts
  function main (line 16) | async function main() {

FILE: examples/llm-as-judge-skills/examples/generate-rubric.ts
  function main (line 13) | async function main() {

FILE: examples/llm-as-judge-skills/examples/pairwise-comparison.ts
  function main (line 13) | async function main() {

FILE: examples/llm-as-judge-skills/src/agents/evaluator.ts
  type EvaluatorAgentConfig (line 13) | interface EvaluatorAgentConfig {
  class EvaluatorAgent (line 19) | class EvaluatorAgent {
    method constructor (line 23) | constructor(agentConfig?: EvaluatorAgentConfig) {
    method score (line 31) | async score(input: DirectScoreInput) {
    method compare (line 38) | async compare(input: PairwiseCompareInput) {
    method generateRubric (line 45) | async generateRubric(input: GenerateRubricInput) {
    method evaluateWithGeneratedRubric (line 52) | async evaluateWithGeneratedRubric(
    method chat (line 93) | async chat(userMessage: string) {

FILE: examples/llm-as-judge-skills/src/config/index.ts
  function validateConfig (line 13) | function validateConfig(): void {

FILE: examples/llm-as-judge-skills/src/tools/evaluation/direct-score.ts
  type DirectScoreInput (line 26) | type DirectScoreInput = z.infer<typeof DirectScoreInputSchema>;
  type DirectScoreOutput (line 53) | type DirectScoreOutput = z.infer<typeof DirectScoreOutputSchema>;
  function executeDirectScore (line 55) | async function executeDirectScore(input: DirectScoreInput): Promise<Dire...

FILE: examples/llm-as-judge-skills/src/tools/evaluation/generate-rubric.ts
  type GenerateRubricInput (line 16) | type GenerateRubricInput = z.infer<typeof GenerateRubricInputSchema>;
  type GenerateRubricOutput (line 48) | type GenerateRubricOutput = z.infer<typeof GenerateRubricOutputSchema>;
  function executeGenerateRubric (line 50) | async function executeGenerateRubric(input: GenerateRubricInput): Promis...

FILE: examples/llm-as-judge-skills/src/tools/evaluation/pairwise-compare.ts
  type PairwiseCompareInput (line 17) | type PairwiseCompareInput = z.infer<typeof PairwiseCompareInputSchema>;
  type PairwiseCompareOutput (line 53) | type PairwiseCompareOutput = z.infer<typeof PairwiseCompareOutputSchema>;
  function evaluatePair (line 55) | async function evaluatePair(
  function executePairwiseCompare (line 124) | async function executePairwiseCompare(input: PairwiseCompareInput): Prom...

FILE: examples/llm-as-judge-skills/tests/evaluation.test.ts
  constant TEST_PROMPT (line 11) | const TEST_PROMPT = 'Explain quantum entanglement to a high school stude...
  constant GOOD_RESPONSE (line 13) | const GOOD_RESPONSE = `Quantum entanglement is like having two magical c...
  constant POOR_RESPONSE (line 26) | const POOR_RESPONSE = `Quantum entanglement is when particles are connec...
  constant MEDIUM_RESPONSE (line 29) | const MEDIUM_RESPONSE = `Quantum entanglement happens when two particles...

FILE: skills/advanced-evaluation/scripts/evaluation_example.py
  function direct_scoring_example (line 28) | def direct_scoring_example() -> dict[str, Any]:
  function pairwise_comparison_example (line 143) | def pairwise_comparison_example() -> dict[str, Any]:
  function rubric_generation_example (line 261) | def rubric_generation_example() -> dict[str, Any]:

FILE: skills/context-compression/scripts/compression_evaluator.py
  class ProbeType (line 56) | class ProbeType(Enum):
  class Probe (line 65) | class Probe:
  class CriterionResult (line 79) | class CriterionResult:
  class EvaluationResult (line 87) | class EvaluationResult:
  class ProbeGenerator (line 188) | class ProbeGenerator:
    method __init__ (line 200) | def __init__(self, conversation_history: str) -> None:
    method generate_probes (line 206) | def generate_probes(self) -> List[Probe]:
    method _extract_facts (line 252) | def _extract_facts(self) -> Dict[str, str]:
    method _extract_files (line 284) | def _extract_files(self) -> List[Dict[str, str]]:
    method _extract_decisions (line 306) | def _extract_decisions(self) -> List[Dict[str, str]]:
  class CompressionEvaluator (line 328) | class CompressionEvaluator:
    method __init__ (line 341) | def __init__(self, model: str = "gpt-5.2") -> None:
    method evaluate (line 345) | def evaluate(self,
    method get_summary (line 396) | def get_summary(self) -> Dict:
    method _get_criteria_for_probe (line 434) | def _get_criteria_for_probe(self, probe_type: ProbeType) -> List[Dict]:
    method _evaluate_criterion (line 457) | def _evaluate_criterion(self,
    method _heuristic_score (line 489) | def _heuristic_score(self,
    method _calculate_dimension_scores (line 515) | def _calculate_dimension_scores(self,
  class StructuredSummarizer (line 542) | class StructuredSummarizer:
    method __init__ (line 574) | def __init__(self) -> None:
    method update_from_span (line 584) | def update_from_span(self, new_content: str) -> str:
    method _extract_from_content (line 607) | def _extract_from_content(self, content: str) -> Dict:
    method _merge_sections (line 640) | def _merge_sections(self, new_info: Dict) -> None:
    method _format_summary (line 667) | def _format_summary(self) -> str:
  function evaluate_compression_quality (line 696) | def evaluate_compression_quality(
  function mock_model_response (line 786) | def mock_model_response(context: str, question: str) -> str:

FILE: skills/context-degradation/scripts/degradation_detector.py
  function measure_attention_distribution (line 45) | def measure_attention_distribution(
  function _estimate_attention (line 81) | def _estimate_attention(
  function detect_lost_in_middle (line 112) | def detect_lost_in_middle(
  function analyze_context_structure (line 166) | def analyze_context_structure(context: str) -> Dict[str, object]:
  class PoisoningDetector (line 225) | class PoisoningDetector:
    method __init__ (line 233) | def __init__(self) -> None:
    method extract_claims (line 245) | def extract_claims(self, text: str) -> List[Dict[str, object]]:
    method detect_poisoning (line 279) | def detect_poisoning(self, context: str) -> Dict[str, object]:
    method _detect_contradictions (line 340) | def _detect_contradictions(self, text: str) -> List[str]:
    method _detect_hallucination_markers (line 363) | def _detect_hallucination_markers(self, text: str) -> List[str]:
  class ContextHealthAnalyzer (line 385) | class ContextHealthAnalyzer:
    method __init__ (line 396) | def __init__(self, context_limit: int = 100_000) -> None:
    method analyze (line 400) | def analyze(
    method _calculate_health_score (line 463) | def _calculate_health_score(
    method _interpret_score (line 477) | def _interpret_score(self, score: float) -> str:
    method _generate_recommendations (line 488) | def _generate_recommendations(
  function analyze_agent_context (line 519) | def analyze_agent_context(

FILE: skills/context-fundamentals/scripts/context_manager.py
  function estimate_token_count (line 62) | def estimate_token_count(text: str) -> int:
  function estimate_message_tokens (line 79) | def estimate_message_tokens(messages: List[Dict[str, Any]]) -> int:
  function count_tokens_by_type (line 94) | def count_tokens_by_type(context: Dict[str, Any]) -> Dict[str, int]:
  class ContextBuilder (line 133) | class ContextBuilder:
    method __init__ (line 149) | def __init__(self, context_limit: int = 100_000) -> None:
    method add_section (line 154) | def add_section(
    method build (line 175) | def build(self, max_tokens: Optional[int] = None) -> str:
    method get_usage_report (line 203) | def get_usage_report(self) -> Dict[str, Any]:
    method _get_status (line 220) | def _get_status(self, total: int) -> str:
  function truncate_context (line 235) | def truncate_context(
  function truncate_messages (line 261) | def truncate_messages(
  function validate_context_structure (line 320) | def validate_context_structure(context: Dict[str, Any]) -> Dict[str, Any]:
  class ProgressiveDisclosureManager (line 377) | class ProgressiveDisclosureManager:
    method __init__ (line 393) | def __init__(self, base_dir: str = ".") -> None:
    method load_summary (line 397) | def load_summary(self, summary_path: str) -> str:
    method load_detail (line 409) | def load_detail(self, detail_path: str, force: bool = False) -> str:
    method get_contextual_info (line 425) | def get_contextual_info(self, reference: Dict[str, Any]) -> str:
  function build_agent_context (line 448) | def build_agent_context(

FILE: skills/context-optimization/scripts/compaction.py
  function estimate_token_count (line 61) | def estimate_token_count(text: str) -> int:
  function estimate_message_tokens (line 84) | def estimate_message_tokens(messages: List[Dict[str, str]]) -> int:
  function categorize_messages (line 104) | def categorize_messages(messages: List[Dict]) -> Dict[str, List[Dict]]:
  function summarize_content (line 141) | def summarize_content(content: str, category: str, max_length: int = 500...
  function summarize_tool_output (line 159) | def summarize_tool_output(content: str, max_length: int = 500) -> str:
  function summarize_conversation (line 186) | def summarize_conversation(content: str, max_length: int = 500) -> str:
  function summarize_document (line 214) | def summarize_document(content: str, max_length: int = 500) -> str:
  function summarize_general (line 231) | def summarize_general(content: str, max_length: int = 500) -> str:
  class ObservationStore (line 245) | class ObservationStore:
    method __init__ (line 263) | def __init__(self, max_size: int = 1000) -> None:
    method store (line 268) | def store(self, content: str, metadata: Optional[Dict] = None) -> str:
    method retrieve (line 287) | def retrieve(self, ref_id: str) -> Optional[str]:
    method mask (line 294) | def mask(self, content: str, max_length: int = 200) -> Tuple[str, Opti...
    method _generate_ref_id (line 310) | def _generate_ref_id(self, content: str) -> str:
    method _extract_key_point (line 315) | def _extract_key_point(self, content: str) -> str:
  class ContextBudget (line 330) | class ContextBudget:
    method __init__ (line 350) | def __init__(self, total_limit: int) -> None:
    method allocate (line 363) | def allocate(self, category: str, amount: int) -> bool:
    method remaining (line 380) | def remaining(self) -> int:
    method get_usage (line 385) | def get_usage(self) -> Dict[str, object]:
    method should_optimize (line 401) | def should_optimize(
  function design_stable_prompt (line 434) | def design_stable_prompt(template: str, dynamic_values: Optional[Dict] =...
  function calculate_cache_metrics (line 460) | def calculate_cache_metrics(
  function generate_cache_recommendations (line 492) | def generate_cache_recommendations(hits: int, misses: int) -> List[str]:

FILE: skills/evaluation/scripts/evaluator.py
  class ScoreLevel (line 33) | class ScoreLevel(Enum):
  class RubricDimension (line 44) | class RubricDimension:
  class AgentEvaluator (line 125) | class AgentEvaluator:
    method __init__ (line 132) | def __init__(self, rubric: Optional[Dict[str, RubricDimension]] = None...
    method evaluate (line 136) | def evaluate(
    method _evaluate_dimension (line 182) | def _evaluate_dimension(
    method _check_factual_accuracy (line 243) | def _check_factual_accuracy(
    method _estimate_expected_tools (line 269) | def _estimate_expected_tools(self, task_type: str) -> int:
    method _score_to_level (line 279) | def _score_to_level(self, score: float) -> str:
  class TestSet (line 298) | class TestSet:
    method __init__ (line 306) | def __init__(self, name: str) -> None:
    method add_test (line 311) | def add_test(self, test: Dict[str, Any]) -> None:
    method filter (line 324) | def filter(self, **criteria: Any) -> List[Dict[str, Any]]:
    method get_complexity_distribution (line 340) | def get_complexity_distribution(self) -> Dict[str, int]:
    method create_standard_tests (line 351) | def create_standard_tests(self) -> "TestSet":
  class EvaluationRunner (line 395) | class EvaluationRunner:
    method __init__ (line 402) | def __init__(self, evaluator: AgentEvaluator, test_set: TestSet) -> None:
    method run_all (line 407) | def run_all(self, verbose: bool = False) -> Dict[str, Any]:
    method run_test (line 425) | def run_test(self, test: Dict[str, Any]) -> Dict[str, Any]:
    method summarize (line 449) | def summarize(self) -> Dict[str, Any]:
  class ProductionMonitor (line 496) | class ProductionMonitor:
    method __init__ (line 504) | def __init__(self, sample_rate: float = 0.01) -> None:
    method should_sample (line 515) | def should_sample(self) -> bool:
    method record_sample (line 522) | def record_sample(
    method get_metrics (line 538) | def get_metrics(self) -> Dict[str, Any]:
    method _generate_alerts (line 564) | def _generate_alerts(

FILE: skills/filesystem-context/scripts/filesystem_context.py
  class ScratchPadManager (line 49) | class ScratchPadManager:
    method __init__ (line 57) | def __init__(self, base_path: str = "scratch", token_threshold: int = ...
    method estimate_tokens (line 62) | def estimate_tokens(self, content: str) -> int:
    method should_offload (line 70) | def should_offload(self, content: str) -> bool:
    method offload (line 77) | def offload(self, content: str, source: str) -> Dict[str, Any]:
    method format_reference (line 104) | def format_reference(self, ref: Dict[str, Any]) -> str:
    method cleanup (line 116) | def cleanup(self, max_age_seconds: int = 3600) -> int:
  class PlanStep (line 139) | class PlanStep:
  class AgentPlan (line 153) | class AgentPlan:
    method to_dict (line 165) | def to_dict(self) -> Dict[str, Any]:
    method save (line 181) | def save(self, path: str = "scratch/current_plan.json") -> None:
    method load (line 193) | def load(cls, path: str = "scratch/current_plan.json") -> AgentPlan:
    method current_step (line 216) | def current_step(self) -> Optional[PlanStep]:
    method complete_step (line 226) | def complete_step(self, step_id: int, notes: Optional[str] = None) -> ...
    method progress_summary (line 240) | def progress_summary(self) -> str:
  class ToolOutputHandler (line 265) | class ToolOutputHandler:
    method __init__ (line 272) | def __init__(self, scratch_pad: Optional[ScratchPadManager] = None) ->...
    method process_output (line 275) | def process_output(self, tool_name: str, output: str) -> str:
  function _demo_scratch_pad (line 292) | def _demo_scratch_pad() -> None:
  function _demo_plan_persistence (line 341) | def _demo_plan_persistence() -> None:
  function _demo_tool_handler (line 377) | def _demo_tool_handler() -> None:
  function _cleanup_demo (line 410) | def _cleanup_demo() -> None:

FILE: skills/hosted-agents/scripts/sandbox_manager.py
  class SandboxState (line 36) | class SandboxState(Enum):
  class UserIdentity (line 47) | class UserIdentity:
  class SandboxConfig (line 60) | class SandboxConfig:
  class Sandbox (line 75) | class Sandbox:
    method execute_command (line 91) | async def execute_command(self, command: str) -> dict[str, Any]:
    method read_file (line 103) | async def read_file(self, path: str) -> str:
    method write_file (line 111) | async def write_file(self, path: str, content: str) -> None:
    method snapshot (line 119) | async def snapshot(self) -> str:
    method _create_snapshot (line 131) | async def _create_snapshot(self) -> str:
    method restore (line 135) | async def restore(self, snapshot_id: str) -> None:
    method terminate (line 139) | async def terminate(self) -> None:
  class RepositoryImage (line 145) | class RepositoryImage:
    method is_stale (line 156) | def is_stale(self, max_age: timedelta = timedelta(minutes=30)) -> bool:
  class ImageBuilder (line 161) | class ImageBuilder:
    method __init__ (line 168) | def __init__(self, github_app_token_provider: Callable[[], str]) -> None:
    method build_image (line 172) | async def build_image(self, repo_url: str) -> RepositoryImage:
    method get_latest_image (line 218) | def get_latest_image(self, repo_url: str) -> Optional[RepositoryImage]:
    method _execute_build_step (line 222) | async def _execute_build_step(self, command: str) -> None:
    method _get_commit_sha (line 226) | async def _get_commit_sha(self) -> str:
    method _finalize_image (line 230) | async def _finalize_image(self) -> str:
  class WarmSandbox (line 236) | class WarmSandbox:
  class WarmPoolManager (line 250) | class WarmPoolManager:
    method __init__ (line 257) | def __init__(
    method get_warm_sandbox (line 268) | async def get_warm_sandbox(self, repo_url: str) -> Optional[WarmSandbox]:
    method _is_valid (line 284) | def _is_valid(self, warm: WarmSandbox) -> bool:
    method maintain_pool (line 297) | async def maintain_pool(self, repo_url: str) -> None:
    method _create_warm_sandbox (line 319) | async def _create_warm_sandbox(self, repo_url: str) -> WarmSandbox:
    method _sync_to_latest (line 341) | async def _sync_to_latest(self, warm: WarmSandbox) -> None:
    method _create_sandbox_from_image (line 347) | async def _create_sandbox_from_image(self, image: RepositoryImage) -> ...
  class SandboxManager (line 352) | class SandboxManager:
    method __init__ (line 360) | def __init__(
    method start_build_loop (line 372) | async def start_build_loop(self) -> None:
    method start_session (line 388) | async def start_session(
    method on_user_typing (line 423) | async def on_user_typing(self, user: UserIdentity, repo_url: str) -> N...
    method end_session (line 435) | async def end_session(self, session_id: str) -> Optional[str]:
    method _configure_for_user (line 456) | async def _configure_for_user(
    method _wait_for_sync (line 472) | async def _wait_for_sync(self, warm: WarmSandbox) -> None:
    method _restore_from_snapshot (line 477) | async def _restore_from_snapshot(self, snapshot_id: str) -> Sandbox:
    method _cold_start (line 481) | async def _cold_start(self, repo_url: str) -> Sandbox:
  class AgentSession (line 486) | class AgentSession:
    method __init__ (line 494) | def __init__(self, sandbox: Sandbox) -> None:
    method read_file (line 499) | async def read_file(self, path: str) -> str:
    method write_file (line 508) | async def write_file(self, path: str, content: str) -> None:
    method mark_sync_complete (line 521) | def mark_sync_complete(self) -> None:
    method _wait_for_sync (line 525) | async def _wait_for_sync(self) -> None:
  function _demo (line 537) | async def _demo() -> None:

FILE: skills/memory-systems/scripts/memory_store.py
  class VectorStore (line 39) | class VectorStore:
    method __init__ (line 46) | def __init__(self, dimension: int = 768) -> None:
    method add (line 53) | def add(self, text: str, metadata: Optional[Dict[str, Any]] = None) ->...
    method search (line 82) | def search(
    method search_by_entity (line 124) | def search_by_entity(
    method _embed (line 159) | def _embed(self, text: str) -> np.ndarray:
    method _time_key (line 170) | def _time_key(self, timestamp: Any) -> str:
    method _matches_filters (line 176) | def _matches_filters(self, metadata: Dict[str, Any], filters: Dict[str...
  class PropertyGraph (line 189) | class PropertyGraph:
    method __init__ (line 197) | def __init__(self) -> None:
    method get_or_create_node (line 204) | def get_or_create_node(
    method create_node (line 222) | def create_node(self, label: str, properties: Optional[Dict[str, Any]]...
    method create_relationship (line 243) | def create_relationship(
    method query (line 279) | def query(self, pattern: Dict[str, Any]) -> List[Dict[str, Any]]:
    method get_node (line 309) | def get_node(self, node_id: str) -> Optional[Dict[str, Any]]:
    method get_relationships (line 313) | def get_relationships(
  class TemporalKnowledgeGraph (line 344) | class TemporalKnowledgeGraph(PropertyGraph):
    method create_temporal_relationship (line 352) | def create_temporal_relationship(
    method query_at_time (line 378) | def query_at_time(
    method query_time_range (line 411) | def query_time_range(
  class IntegratedMemorySystem (line 455) | class IntegratedMemorySystem:
    method __init__ (line 464) | def __init__(self) -> None:
    method start_session (line 469) | def start_session(self, session_id: str) -> None:
    method store_fact (line 477) | def store_fact(
    method retrieve_memories (line 516) | def retrieve_memories(
    method retrieve_entity_context (line 548) | def retrieve_entity_context(self, entity: str) -> Dict[str, Any]:
    method consolidate (line 578) | def consolidate(self) -> None:

FILE: skills/multi-agent-patterns/scripts/coordination.py
  class MessageType (line 32) | class MessageType(Enum):
  class AgentMessage (line 43) | class AgentMessage:
  class AgentCommunication (line 60) | class AgentCommunication:
    method __init__ (line 67) | def __init__(self) -> None:
    method send (line 72) | def send(self, message: AgentMessage) -> None:
    method receive (line 80) | def receive(self, agent_id: str) -> List[AgentMessage]:
    method broadcast (line 86) | def broadcast(
  class SupervisorAgent (line 110) | class SupervisorAgent:
    method __init__ (line 117) | def __init__(self, name: str, communication: AgentCommunication) -> None:
    method register_worker (line 125) | def register_worker(self, worker_id: str, capabilities: List[str]) -> ...
    method decompose_task (line 134) | def decompose_task(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
    method assign_task (line 169) | def assign_task(self, subtask: Dict[str, Any], worker_id: str) -> None:
    method select_worker (line 188) | def select_worker(self, subtask: Dict[str, Any]) -> str:
    method aggregate_results (line 218) | def aggregate_results(
    method run_workflow (line 238) | def run_workflow(self, task: Dict[str, Any]) -> Dict[str, Any]:
    method _simulate_worker_response (line 283) | def _simulate_worker_response(
    method _send (line 298) | def _send(self, message: AgentMessage) -> None:
  class HandoffProtocol (line 308) | class HandoffProtocol:
    method __init__ (line 315) | def __init__(self, communication: AgentCommunication) -> None:
    method create_handoff (line 318) | def create_handoff(
    method accept_handoff (line 338) | def accept_handoff(self, agent_id: str) -> Optional[AgentMessage]:
    method transfer_with_state (line 348) | def transfer_with_state(
  class ConsensusManager (line 391) | class ConsensusManager:
    method __init__ (line 399) | def __init__(self) -> None:
    method initiate_vote (line 403) | def initiate_vote(
    method submit_vote (line 417) | def submit_vote(
    method calculate_weighted_consensus (line 435) | def calculate_weighted_consensus(self, topic_id: str) -> Dict[str, Any]:
  class AgentFailureHandler (line 490) | class AgentFailureHandler:
    method __init__ (line 498) | def __init__(
    method handle_failure (line 508) | def handle_failure(
    method _activate_circuit_breaker (line 535) | def _activate_circuit_breaker(self, agent_id: str) -> None:
    method _find_alternative_agent (line 539) | def _find_alternative_agent(self, failed_agent: str) -> str:
    method is_available (line 546) | def is_available(self, agent_id: str) -> bool:
    method record_success (line 555) | def record_success(self, agent_id: str) -> None:

FILE: skills/project-development/scripts/pipeline_template.py
  class Item (line 99) | class Item:
  class ParsedResult (line 113) | class ParsedResult:
  function get_batch_dir (line 132) | def get_batch_dir(batch_id: str) -> Path:
  function get_item_dir (line 140) | def get_item_dir(batch_id: str, item_id: str) -> Path:
  function get_output_dir (line 148) | def get_output_dir(batch_id: str) -> Path:
  function stage_acquire (line 160) | def stage_acquire(batch_id: str, limit: int | None = None) -> list[Path]:
  function fetch_items_from_source (line 194) | def fetch_items_from_source(limit: int | None = None) -> list[Item]:
  function stage_prepare (line 216) | def stage_prepare(batch_id: str) -> int:
  function generate_prompt (line 256) | def generate_prompt(item_data: dict[str, Any]) -> str:
  function stage_process (line 271) | def stage_process(
  function call_llm (line 336) | def call_llm(prompt: str, model: str) -> str:
  function stage_parse (line 379) | def stage_parse(batch_id: str) -> list[dict[str, Any]]:
  function parse_response (line 424) | def parse_response(text: str) -> ParsedResult:
  function extract_section (line 465) | def extract_section(text: str, section_name: str) -> str | None:
  function extract_field (line 475) | def extract_field(text: str, field_name: str) -> str | None:
  function extract_list_items (line 485) | def extract_list_items(text: str, section_name: str) -> list[str]:
  function extract_score (line 498) | def extract_score(
  function stage_render (line 521) | def stage_render(batch_id: str) -> Path | None:
  function render_html (line 554) | def render_html(results: list[dict[str, Any]], batch_id: str) -> str:
  function stage_clean (line 603) | def stage_clean(batch_id: str, from_stage: str | None = None) -> int:
  function stage_estimate (line 662) | def stage_estimate(batch_id: str) -> dict[str, Any] | None:
  function main (line 726) | def main() -> None:

FILE: skills/tool-design/scripts/description_generator.py
  class ToolSpec (line 48) | class ToolSpec(Protocol):
  class _BuiltToolSpec (line 65) | class _BuiltToolSpec:
  function generate_tool_description (line 111) | def generate_tool_description(tool_spec: ToolSpec) -> str:
  function generate_usage_context (line 128) | def generate_usage_context(tool_spec: ToolSpec) -> str:
  function _generate_parameters (line 151) | def _generate_parameters(parameters: Sequence[Dict[str, Any]]) -> str:
  function _generate_returns (line 166) | def _generate_returns(returns: Optional[Dict[str, Any]]) -> str:
  function _generate_errors (line 175) | def _generate_errors(errors: Sequence[Dict[str, Any]]) -> str:
  class ToolDescriptionEvaluator (line 189) | class ToolDescriptionEvaluator:
    method evaluate (line 204) | def evaluate(self, description: str, tool_spec: ToolSpec) -> Dict[str,...
    method _check_clarity (line 221) | def _check_clarity(self, description: str) -> float:
    method _check_completeness (line 236) | def _check_completeness(self, description: str, tool_spec: ToolSpec) -...
    method _check_accuracy (line 253) | def _check_accuracy(self, description: str, tool_spec: ToolSpec) -> fl...
    method _check_actionability (line 271) | def _check_actionability(self, description: str) -> float:
    method _check_consistency (line 281) | def _check_consistency(self, description: str, tool_spec: ToolSpec) ->...
  class ErrorMessageGenerator (line 299) | class ErrorMessageGenerator:
    method generate (line 329) | def generate(self, error_type: str, context: Dict[str, str]) -> str:
  class ToolSchemaBuilder (line 343) | class ToolSchemaBuilder:
    method __init__ (line 350) | def __init__(self, name: str) -> None:
    method set_description (line 360) | def set_description(self, short: str, detailed: str) -> "ToolSchemaBui...
    method add_parameter (line 370) | def add_parameter(
    method set_returns (line 393) | def set_returns(
    method add_error (line 410) | def add_error(
    method build (line 428) | def build(self) -> "_BuiltToolSpec":
    method add_trigger (line 449) | def add_trigger(self, trigger: str) -> "ToolSchemaBuilder":
    method add_example (line 457) | def add_example(