{
  "package_slug": "scripted_dependency_tracking_benchmark_examples",
  "title": "Benchmarks",
  "summary": "Current paired and single benchmark examples with scripted conversations, dependency-graph snapshots, rendered graph visualizations, and the text-state ledgers used to reconstruct conversation, theory, and memory files.",
  "scripted_conversation_source": "ALL_CONVERSATIONS benchmark fixture",
  "benchmark_counts": {
    "total": 22,
    "paired": 3,
    "single": 19
  },
  "shared_runtime": {
    "python_version": "3.13.12",
    "git_commit": "f95ca4e2"
  },
  "included_file_types": [
    "scripted_conversations.json",
    "dependency_graphs/dependency_graph.json",
    "dependency_graphs/dep_viz_*.png",
    "piece_tables/pt_conv_*.json",
    "piece_tables/pt_kf_*.json",
    "piece_tables/pt_mem_*.json"
  ],
  "excluded_file_types": [
    "conv*.log",
    "node_boundary_recipients*.json",
    "event_logs/",
    "knowledge_files/",
    "observations/",
    "performance/",
    "dependency_graphs/dep_viz_*.dot"
  ],
  "preview_image": "suite_preview.png",
  "benchmarks": [
    {
      "benchmark_name": "pair_01_02",
      "group": "paired",
      "conversation_numbers": [
        1,
        2
      ],
      "created_at": "2026-03-19T14:07:00.326771",
      "summary": "Two-conversation knowledge-version example showing inserted-node dependencies, then a follow-up version where static knowledge dependencies persist but prior dynamic state does not.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 1,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "knowledge.compute"
          ]
        },
        {
          "conversation_number": 2,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.read_version",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 2,
      "piece_table_count": 4,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "pair_03_04",
      "group": "paired",
      "conversation_numbers": [
        3,
        4
      ],
      "created_at": "2026-03-19T14:07:04.552548",
      "summary": "Tutor-guided learning example that stores topics in memory, writes a new function to knowledge, and then reuses that memory and knowledge state in a follow-up observation.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 3,
          "api_actions": [
            "tutor.send",
            "memory.insert_node",
            "memory.compute",
            "knowledge.create_version",
            "knowledge.insert_node",
            "observe.observe"
          ]
        },
        {
          "conversation_number": 4,
          "api_actions": [
            "memory.compute",
            "knowledge.insert_node",
            "knowledge.compute",
            "observe.observe"
          ]
        }
      ],
      "dep_viz_png_count": 4,
      "piece_table_count": 7,
      "ledger_kinds": [
        "conversation",
        "theory",
        "memory"
      ]
    },
    {
      "benchmark_name": "pair_05_06",
      "group": "paired",
      "conversation_numbers": [
        5,
        6
      ],
      "created_at": "2026-03-19T14:07:08.503527",
      "summary": "Memory-editing example that builds and revises storage helpers, then separately exercises observation, version listing, and promotion behavior across knowledge versions.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 5,
          "api_actions": [
            "memory.read",
            "memory.insert_node",
            "memory.compute",
            "knowledge.create_version",
            "knowledge.compute",
            "memory.find_all_nodes",
            "memory.replace_node"
          ]
        },
        {
          "conversation_number": 6,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.list_versions",
            "observe.observe"
          ]
        }
      ],
      "dep_viz_png_count": 3,
      "piece_table_count": 7,
      "ledger_kinds": [
        "conversation",
        "theory",
        "memory"
      ]
    },
    {
      "benchmark_name": "conv_07",
      "group": "single",
      "conversation_numbers": [
        7
      ],
      "created_at": "2026-03-19T14:07:10.096591",
      "summary": "Knowledge proxy-computation example covering dynamic code that calls the conversation API directly for context clearing, appended notes, and multiple API calls inside one computed expression.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 7,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_08",
      "group": "single",
      "conversation_numbers": [
        8
      ],
      "created_at": "2026-03-19T14:07:12.757834",
      "summary": "Precise dynamic-dependency example combining imported symbols, inserted helper functions, and redefined dynamic values in date computations.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 8,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_09",
      "group": "single",
      "conversation_numbers": [
        9
      ],
      "created_at": "2026-03-19T14:07:14.853632",
      "summary": "Dynamic-state reload example showing that module edits reset transient computed values until those values are established again.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 9,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute",
            "knowledge.insert_node"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_10",
      "group": "single",
      "conversation_numbers": [
        10
      ],
      "created_at": "2026-03-19T14:07:27.069080",
      "summary": "Find-operations example covering function, class, method, index-path, and XPath-style node queries over a small knowledge module.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 10,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "knowledge.find_node",
            "knowledge.find_all_nodes"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_11",
      "group": "single",
      "conversation_numbers": [
        11
      ],
      "created_at": "2026-03-19T14:07:33.339993",
      "summary": "CST-editing example covering inserts, replacements, reordering, nested class edits, and one intentionally invalid insertion target.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 11,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "knowledge.replace_node",
            "knowledge.move_node"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_12",
      "group": "single",
      "conversation_numbers": [
        12
      ],
      "created_at": "2026-03-19T14:07:34.177474",
      "summary": "Knowledge proxy-computation example where dynamically executed code calls the tutor API directly to request user data and branch on validated responses.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 12,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_13",
      "group": "single",
      "conversation_numbers": [
        13
      ],
      "created_at": "2026-03-19T14:07:38.494941",
      "summary": "CST edge-case example covering renames, scalar replacements, node deletion, failed multi-node targeting, and whole-class replacement.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 13,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.replace_node",
            "knowledge.read_version",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_14",
      "group": "single",
      "conversation_numbers": [
        14
      ],
      "created_at": "2026-03-19T14:07:41.980129",
      "summary": "Version-close example showing that closing a knowledge version clears its dynamic state while leaving static file content readable.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 14,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute",
            "knowledge.close"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 3,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_15",
      "group": "single",
      "conversation_numbers": [
        15
      ],
      "created_at": "2026-03-19T14:07:43.571032",
      "summary": "List-manipulation example that tracks dependencies through append calls, slicing, and conditional reads over a dynamically populated list.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 15,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_16",
      "group": "single",
      "conversation_numbers": [
        16
      ],
      "created_at": "2026-03-19T14:07:48.021356",
      "summary": "Knowledge proxy-computation example tracing API-derived values through lists, dicts, nested structures, helper functions, attribute access, and subscripting.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 16,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute",
            "memory.insert_node"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 3,
      "ledger_kinds": [
        "conversation",
        "theory",
        "memory"
      ]
    },
    {
      "benchmark_name": "conv_17",
      "group": "single",
      "conversation_numbers": [
        17
      ],
      "created_at": "2026-03-19T14:07:50.238775",
      "summary": "Memory CST and proxy-computation example covering insert, find, replace, and compute operations over memory-resident helpers that can participate in direct API calls.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 17,
          "api_actions": [
            "memory.read",
            "memory.insert_node",
            "memory.find_node",
            "memory.find_all_nodes",
            "memory.replace_node",
            "memory.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "memory"
      ]
    },
    {
      "benchmark_name": "conv_18",
      "group": "single",
      "conversation_numbers": [
        18
      ],
      "created_at": "2026-03-19T14:07:56.367326",
      "summary": "Control-flow example showing dependencies propagating through if/else branches, loops, branch switching, and API-backed loop bounds.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 18,
          "api_actions": [
            "knowledge.create_version",
            "memory.insert_node",
            "knowledge.insert_node",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 3,
      "ledger_kinds": [
        "conversation",
        "theory",
        "memory"
      ]
    },
    {
      "benchmark_name": "conv_19",
      "group": "single",
      "conversation_numbers": [
        19
      ],
      "created_at": "2026-03-19T14:08:03.519740",
      "summary": "Initialization example that incrementally assembles a module and checks that reads and method calls depend only on the inserted definitions they actually use.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 19,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.insert_node",
            "conversation.clear_context",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_21",
      "group": "single",
      "conversation_numbers": [
        21
      ],
      "created_at": "2026-03-19T14:08:15.276393",
      "summary": "Loop-tracking example covering tutor-driven loop counts, API-backed while conditions, nested loops, break/continue behavior, and comprehension filters.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 21,
          "api_actions": [
            "knowledge.create_version",
            "memory.insert_node",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 3,
      "ledger_kinds": [
        "conversation",
        "theory",
        "memory"
      ]
    },
    {
      "benchmark_name": "conv_33",
      "group": "single",
      "conversation_numbers": [
        33
      ],
      "created_at": "2026-03-19T14:08:17.720662",
      "summary": "Read/write dependency example contrasting blind overwrites, simple reads, read-modify-write chains, and function-mediated global access.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 33,
          "api_actions": [
            "knowledge.create_version",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 1,
      "piece_table_count": 2,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_34",
      "group": "single",
      "conversation_numbers": [
        34
      ],
      "created_at": "2026-03-19T14:08:18.786042",
      "summary": "Minimal observe-branch example showing branch observation promotion and verification against the latest mainline version.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 34,
          "api_actions": [
            "knowledge.create_version",
            "observe.observe_branch",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 2,
      "piece_table_count": 3,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_35",
      "group": "single",
      "conversation_numbers": [
        35
      ],
      "created_at": "2026-03-19T14:08:23.236793",
      "summary": "Typical replace-observation flow where an updated version breaks replication, a replacement computation is supplied, and a follow-up observation can promote again.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 35,
          "api_actions": [
            "knowledge.create_version",
            "observe.observe",
            "observe.replace_observation"
          ]
        }
      ],
      "dep_viz_png_count": 3,
      "piece_table_count": 5,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_36",
      "group": "single",
      "conversation_numbers": [
        36
      ],
      "created_at": "2026-03-19T14:08:28.116702",
      "summary": "Branch-and-merge example that seeds a main observation, promotes branch-only work in a buffer, and then merges once the branch surpasses the main chain.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 36,
          "api_actions": [
            "knowledge.create_version",
            "observe.observe",
            "observe.observe_branch",
            "knowledge.compute"
          ]
        }
      ],
      "dep_viz_png_count": 4,
      "piece_table_count": 6,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    },
    {
      "benchmark_name": "conv_37",
      "group": "single",
      "conversation_numbers": [
        37
      ],
      "created_at": "2026-03-19T14:08:30.301197",
      "summary": "Buffer-namespace edge case showing that observe-branch can seed a buffer on a replication-broken update while replace-observation on that buffer is rejected.",
      "api_actions_by_conversation": [
        {
          "conversation_number": 37,
          "api_actions": [
            "knowledge.create_version",
            "observe.observe",
            "observe.observe_branch",
            "observe.replace_observation"
          ]
        }
      ],
      "dep_viz_png_count": 3,
      "piece_table_count": 4,
      "ledger_kinds": [
        "conversation",
        "theory"
      ]
    }
  ]
}