{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f42c5502",
   "metadata": {
    "papermill": {
     "duration": 0.001445,
     "end_time": "2026-05-28T05:13:49.013941+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:49.012496+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# 29 · Voyager — persistent skill library with real subprocess execution\n",
    "\n",
    "> **TL;DR.** Each task: vector-search the library for a relevant skill; if found, reuse it; otherwise write a new Python function and store it. **The skill code is actually executed in a fresh isolated Python subprocess** — the LLM's predicted result is also captured for comparison.\n",
    "\n",
    "| Property | Value |\n",
    "|---|---|\n",
    "| Origin | Wang et al., *Voyager* (2023). [arXiv:2305.16291](https://arxiv.org/abs/2305.16291) |\n",
    "| Skill = | named Python function + docstring + example invocation |\n",
    "| Index | vector store over skill descriptions |\n",
    "| Persistence | `arch.skills: list[dict]` instance attribute |\n",
    "| **Execution** | `subprocess.run([sys.executable, '-I', '-c', script], timeout=5)` — fresh isolated interpreter |\n",
    "| Cost | 1 retrieve + 1 decide + (1 write OR 1 apply) ≈ 3 LLM calls + 1 subprocess per task |\n",
    "\n",
    "Each skill is run in a **fresh isolated Python subprocess** (`-I` flag = no env vars, no user site, no PYTHONPATH). 5-second timeout caps runaway code. The LLM's predicted result is preserved on the trace so we can compare prediction vs reality."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec37897",
   "metadata": {
    "papermill": {
     "duration": 0.005546,
     "end_time": "2026-05-28T05:13:49.033431+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:49.027885+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 2 · Architecture at a glance\n",
    "\n",
    "```mermaid\n",
    "flowchart LR\n",
    "    A([task]) --> R[Retrieve top skill]\n",
    "    R --> D{Reuse or write?}\n",
    "    D -->|reuse| AE[Apply existing skill]\n",
    "    D -->|write_new| W[Write new skill<br/><sub>store in library + index</sub>]\n",
    "    W --> AN[Apply new skill]\n",
    "    AE --> Z([answer])\n",
    "    AN --> Z\n",
    "\n",
    "    L[(skill library<br/>persists across runs)]\n",
    "    R <-.search.-> L\n",
    "    W -.add.-> L\n",
    "\n",
    "    style D fill:#fff3e0,stroke:#f57c00\n",
    "    style W fill:#fce4ec,stroke:#c2185b\n",
    "    style L fill:#f3e5f5,stroke:#7b1fa2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46d014d1",
   "metadata": {
    "papermill": {
     "duration": 0.007493,
     "end_time": "2026-05-28T05:13:49.048958+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:49.041465+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 3 · Theory\n",
    "\n",
    "### 3.0 · Why a library\n",
    "\n",
    "Reflexion (nb 18) accumulates *verbal lessons* about past failures. Voyager accumulates *reusable code* for past successes. Both are episodic memory variants; Voyager's value is that the stored artefact is *executable*.\n",
    "\n",
    "### 3.1 · Why the decider is categorical\n",
    "\n",
    "`_SkillDecision.action: Literal['reuse', 'write_new']` — categorical, not numeric. Routing is `if action == 'reuse'`. No flat-scoring pathway."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bee21109",
   "metadata": {
    "papermill": {
     "duration": 0.002984,
     "end_time": "2026-05-28T05:13:49.054953+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:49.051969+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 4 · Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1eede1a4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-28T05:13:49.063197Z",
     "iopub.status.busy": "2026-05-28T05:13:49.063197Z",
     "iopub.status.idle": "2026-05-28T05:13:52.065418Z",
     "shell.execute_reply": "2026-05-28T05:13:52.064091Z"
    },
    "papermill": {
     "duration": 3.008477,
     "end_time": "2026-05-28T05:13:52.066431+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:49.057954+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">LLM: meta-llama/Llama-</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">3.3</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">-70B-Instruct</span> <span style=\"color: #00ff00; text-decoration-color: #00ff00\">────────────────────────────────────────────────────────────────────────────</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1;36mLLM: meta-llama/Llama-\u001b[0m\u001b[1;36m3.3\u001b[0m\u001b[1;36m-70B-Instruct\u001b[0m \u001b[92m────────────────────────────────────────────────────────────────────────────\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from agentic_architectures import get_llm, enable_langsmith, settings\n",
    "from agentic_architectures.architectures import Voyager\n",
    "from agentic_architectures.ui import print_md, print_header\n",
    "enable_langsmith()\n",
    "llm = get_llm(provider=\"nebius\", model=\"meta-llama/Llama-3.3-70B-Instruct\", temperature=0.2)\n",
    "print_header(f\"LLM: {llm.model}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c341acd",
   "metadata": {
    "papermill": {
     "duration": 0.006692,
     "end_time": "2026-05-28T05:13:52.079122+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:52.072430+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 5 · Library walkthrough"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6e0caf40",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-28T05:13:52.088111Z",
     "iopub.status.busy": "2026-05-28T05:13:52.088111Z",
     "iopub.status.idle": "2026-05-28T05:13:52.112353Z",
     "shell.execute_reply": "2026-05-28T05:13:52.111778Z"
    },
    "papermill": {
     "duration": 0.03125,
     "end_time": "2026-05-28T05:13:52.114359+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:52.083109+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- _SkillDecision ---\n",
      "{\n",
      "  \"description\": \"Per-task decision: reuse existing or write new?\",\n",
      "  \"properties\": {\n",
      "    \"action\": {\n",
      "      \"description\": \"'reuse' if the retrieved skill genuinely solves the task; 'write_new' otherwise.\",\n",
      "      \"enum\": [\n",
      "        \"reuse\",\n",
      "        \"write_new\"\n",
      "      ],\n",
      "      \"title\": \"Action\",\n",
      "    ...\n",
      "\n",
      "--- _NewSkillSpec ---\n",
      "{\n",
      "  \"description\": \"Definition of a newly-written skill (one Python function).\",\n",
      "  \"properties\": {\n",
      "    \"function_name\": {\n",
      "      \"description\": \"The Python identifier of the function you're defining (snake_case, e.g. 'factorial', 'fibonacci'). NOT a schema or class name.\",\n",
      "      \"title\": \"Function Name\",\n",
      "      \"type\": \"string\"\n",
      "    },\n",
      "    \"description\": {\n",
      "      \"description\": \"ONE sentence describing what the skill does. This is what gets embedded for future retrieval \\u2014 be specific.\",\n",
      "      \"...\n"
     ]
    }
   ],
   "source": [
    "from agentic_architectures.architectures.voyager import _NewSkillSpec, _SkillDecision\n",
    "import json\n",
    "print('--- _SkillDecision ---')\n",
    "print(json.dumps(_SkillDecision.model_json_schema(), indent=2)[:300] + '...')\n",
    "print()\n",
    "print('--- _NewSkillSpec ---')\n",
    "print(json.dumps(_NewSkillSpec.model_json_schema(), indent=2)[:500] + '...')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f5ff3f4",
   "metadata": {
    "papermill": {
     "duration": 0.003252,
     "end_time": "2026-05-28T05:13:52.122453+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:52.119201+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 7 · Build the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2e53b048",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-28T05:13:52.136315Z",
     "iopub.status.busy": "2026-05-28T05:13:52.136315Z",
     "iopub.status.idle": "2026-05-28T05:13:53.802447Z",
     "shell.execute_reply": "2026-05-28T05:13:53.801496Z"
    },
    "papermill": {
     "duration": 1.674775,
     "end_time": "2026-05-28T05:13:53.804447+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:52.129672+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATAAAAITCAIAAAAPSdehAAAQAElEQVR4nOydB0AUxxrHZ6/Qu3QQAbErioKxFxB719h7i5pijd3YYxJjeWrUaDTGFjX2xN5rNPbekCIioNJ7ud333S2cJ94dHHB4u/v9nuHtzszO7u3Mf7+Zb3ZnJAzDEARBDAMJQRDEYEBBIogBgYJEEAMCBYkgBgQKEkEMCBQkghgQKMhPRtijlOe3UhLf5Gam05SIomWMCP7SDGwztHwsihKJGJpW2aUoQt4ngB3liBVFKEa+x+YgD6CIcjxLmYMyXBkL6WFDOfSlmhIQSyhZ7gejYlIjSmJEzCwlbhWN/VraE6S0oXAcsoy5dyn+9tmklAQZqIISEWMTkVgK0gOpiSgxYWTyQIaWp6TEFCNT1ac8EKIoEcPQVAFBKhRGvVeUMpZSyI9WTUkYhYDZPOX/T+epVHlqFpGE0LkfXLxICinp7CySkyGTyeQXX76aaZsBLgQpJVCQZcf9y4lX/nknyyX2LkZ1WlpX9rMmXCY1Kfvi/rhXzzNysmj3Siadv3AnSIlBQZYRWxeFgVWsXNe8VT++2ZPnd5PP73kry2F6jitfzsWYICUABVkWrJ4YUs5Z2ndKBcJfLh14c/dics3GVs27OxKkuKAg9c4vk0LqtbJo0M6ZCIA1k0M6j3J2r2xBkGKBgtQvUEFbDXSoXJvb3UWdWDc1pKq/ZYvPnQiiOyKC6I11U0ICWtsISo3A6B99Hv+X8vhmEkF0BwWpL7Z9H25tLw1oLcTBusC+Dmd3viWI7qAg9cKja0mJ73L57cXRQpW61jb20j+XRBBER1CQeuHS/rcVa5sRAdNvaoW41zkZGVkE0QUUZOnz7FZyTg5pN9iVCBtrB8n+lTEE0QUUZOlz7Wi8jQO+JEzqBdsmvMkhiC6gIEuf5PjcWk1tSNkSHBwcFRVFdOTFixcdO3Yk+qF6gLVIRO5ciCNIkUFBljLR4RkwsuvbuEwFGR0dnZCQQHTn0aNHRJ+YmItD7qQTpMhgy6qUeX47RWpEEf3AMMyff/75zz//REREeHl5NWjQYMyYMbdv3x49ejTEdunSpXnz5kuXLgW7t2fPnuvXr79+/drb27tr1649e/ZkcwgKChoxYsSZM2fgqIEDB27duhUC/f39J0yY0L9/f1LaWDtKk99iq1UHUJClTGJMttRYX4LcuXPnpk2bxo8f37hx43Pnzv3yyy/m5uZDhw5dsWIFBB48eNDNzQ2SgSZBijNnzqQoKjw8/Mcff3RxcYFDIEoqle7fv79+/fogy3r16kGCEydOgMKJfrB1kL6LREerDqAgS5msTEYi1VdH4NatW9WrV2d7fd26dQsICEhPV9MgXLx4cVpamqur3M0L1u/QoUNXrlxhBQkKtLa2njx5MikTLG2kNK2vxxMvQUGWMvIPffVWA2vXrr1q1ar58+f7+fk1a9bM3V39J4jQsgVbevnyZWjZsiGs5WQBSZMyQ0QRGl+W1gEUZCkjNSbpyTTRD/369YM26vnz5+fNmyeRSMCz+s033zg4OKimoWl63Lhx2dnZX331FZhHS0vL4cOHqyYwMjIiZUVqQjYRoSB1AAVZyljZS95EZBL9IBKJuikIDQ3977//1q9fn5qaunz5ctU0T548efjw4Zo1a6CjyIakpKQ4On6abxQT3+aIpdhk1QEc9ihlKtYyy9WbWxG8L+BBhQ3wnfbp06dv375Pnz4tkCYxMRH+KhUYqoB8IlLeZVva4UNfB1CQpYxnNStooj27rZePj44dO/btt99euHAhKSnp0qVLMHoBvUr5ST094e/JkycfPHgAWoXWLIxnJCcng4t1yZIlMDoCA5VqM/Tw8Hj37h04bJW9zdIlKZ72rGZKkCKDgix9zK3Ed88lEj0wa9Ys0NvEiRNhOHHBggUw6ghjGxAO3p1OnTqtW7cOXD7Ozs4LFy68f/9+YGAgjC5++eWXMAgJQlUORarSpEmTOnXqgNP1+PHjpLSJDpd7gBu0wxk9dABnDCh9rp+I/+9Y/JfLfIiw2fFTRGYaPWyeF0GKDFrI0iegtZ1ITF08KPQvdOOjc4L6OhBEF7DDrRdqNbG8dzGpaRf11TE+Pr579+5qoywsLMBxqjYKGqubNm0i+mGzAqLjJUGbGQZg1EbtWhZhYkFVqIqzXekGNln1xcbvQsu5GnUdrWbsHu65pioO44eaxgkpigJtEP2QlZUFpyY6XhJ4j0xN1fhsMlJlG2eHfbVc6I32YoCC1CO/TAzpPs7VpYLgpg5YNyWksr9lYC+ceE5nsA+pR7p+5bx/1WsiMH6f98Le3QjVWDzQQuqXxLeZ2354NXyep6mFILrrv04P8W1q07A9LoxVTFCQeudNVMbun6Oq+FsE9+fz5OUxkekHVr+2czXqNc6DIMUFBVlGbJgZCrc6qI99RV8ezpu8a9nLuKjsOi2tGnXE1wBKBAqy7Di86XXEo3SpicjH17wlL7pYD/9NvHM+KfFtjnU5yYAZngQpMSjIsubwpqhXzzJysuXrE5taiMwsJKaWlJGRRKZSDsoVjtkVVMUiSvbREsjyVVapD1ZKFskTsyspv0ckXwSWUay3rBKo+EqR/W4z70QqKytTio86mfz1XonqissMk5Uly0ylU5NysjIZCLdxMGo/zNG6nAlBSgMU5KchMT7r5vGEmIistCSZTEbDGKPq0sXyXeb9yuQgKlr24fF5yvlQkGJKkSxvn6YhWxHInpYVLOL38stPnpcPKz/FvmrFUF4P5CaWUkbGlI2jpHI9yyp1hbVsSRmAguQtPXr0WLp0KfshCMIV8NU53pKbmyuRYPlyDCww3oKC5CJYYLwFBclFsMB4S05OjlQqJQinQEHyFrSQXAQLjLegILkIFhhvQUFyESwwfkLTNIwwi8VignAKFCQ/QfPIUbDM+AkKkqNgmfETFCRHwTLjJyhIjoJlxk/wrQCOgoLkJ2ghOQqWGT9BQXIULDN+goLkKFhm/AT7kBwFBclP0EJyFCwzfoKC5ChYZvxEJpOhILkIlhk/AQuJb5ZzERQkP0GnDkdBQfIT7ENyFCwzfiISiWxtbQnCNVCQvCUuLo4gXAMFyU+gvQqtVoJwDRQkP0FBchQUJD9BQXIUFCQ/QUFyFBQkP0FBchQUJD9BQXIUFCQ/QUFyFBQkP0FBchQUJD9BQXIUFCQ/QUFyFBQkP0FBchQUJD9BQXIUFCQ/QUFyFBQkP0FBchQUJD9BQXIUEUH4iEgkL1mapgnCKSiGYQjCI3x9fZWTd0DhUgpGjBgxZswYghg8aCH5RsWKFUX5iMVi+Ovh4dG7d2+CcAEUJN/o2LEj215VEhgYaGdnRxAugILkG0OGDClfvrxy19XVtXv37gThCChIvgHN1J49exoZGbG7jRo1cnNzIwhHQEHykL59+7JG0sXFpVevXgThDkL0sl7YH5OVSnJkaqIkIiaXptREMEQsITJ1h4hFlIxWcw8pQonEjNpDKIqBWHUHwQOSoon6EqEYwlBEA3JvqmpJRkdHP3782NHRsWatmtCjpGVEVyiKiCgi0zhuwohElJZRFUpxqVoql0REcrUOykgkVG5uIZXTyJhUDbBy9zEjfEFYgvzrf+FvX+aKpPJhutxsNT9cLKZkMjXhDMWAv5JWFyWSEFrdCLxcdWIRra5KQWUF/dBqZSwijIZqShGiqagoxX8FSjJ/zAN+rPofpfYolYukKLmSNVYPkZjSEgvHwuVqqVzyB5zWNxckRpTaMvogjTGBNKZmoqHzvAkvEJAgT++Mfn47rcs3bhYWpgThEcf/iIiPzhm12IdwH6EI8uD6yDeRWX0m86HMkI+5sP/16+fpIxdxvnyF4tSJDsnyb41jcbylWTfX3Bxy7fgbwnEEIciIp6nQX/PxRUHyGTNLSeTTLMJxBPG1R0YyXQw3I8ItwI2UmcL5YhbK51f4Cj3voWUUoQjXwe8hEZ6gcE9yXpEoSIQnwHArhRYSQQwEmmZ4oEgUJMITpFIRxf1BA4EIkgdtGaQQcnJoMVpIjoBOVv4jFyP3n7v4+RXCF3jx0BWGheTDABVSCAzhgyaFIUiGH09PRBtikYiIOF/OgmiyUoovEAnCa2Q0Tbj/gqQgLKTiQ1m0kTyHH09cdOrolzlzp0yazJ8ZihMTE1oG+Z89d5Jo/WlDh/da8b8fSNnCjycuCrIU6NYj+HV0lNqoZs2CgoPbEz5S8p82b/60I0cPEkQFfFOnpMTERIPd0BQbFNiG8JSS/7SnTx8FBDQkpYT8XVZ8U4cTFGPEGNpjYrHYycll564t8+b+1KxpYHx83Jq1yx48vJuZmQnVaNCAEeXLV7h958bESaMhff8BXRo3br5w/tIu3YIg6sKlM/fu3T544MzSpQtTU1OW/rwW0uTm5m7ctObqtUtv3sTUrFmnW5deDRo0SUtL69o9aPCgUQP6D2NPLZPJOndt2aXz56NGfq32pIVe/MuX4UuXL4ILcHVxa9o0cNjQMew0rfv277p69eLjxw+MjI1r+9YdPvxLN1d3CN9/YPfWbb+tWLZ+zrwp4eGh3t4+n/fs37ZNJza302eO//772uSU5EaNmvX+fKDqLVL+NDjqhx/nRLwMq1PHHy5S9WL+/ffimbPH792/nZycVK1qzYEDR/jV8YdwaPrC3yU/L1i7bvnfB8+pvTlEF+TvshLOI4gmK6N7B0MqlYaGhcC/RQuW+dbyA5FMmPTFnbs3J4yfsem3XbY2dmO/HBz1+hXUrcWLVkD67dsOghrZA/85st/Hp8qSn34xM/1gesKVq37as3dHt669d2z/u3mzIKj95y+cNjc3b9ig6cWLZ5TJbty8lp6eHhTYVtNJtV85WOyvvh5aq2YdkErv3oNOnzkG54Xw+/fvrFq9pEaN2vPn/zxt6ryEhPhF389S/liQFiT7dtLsM6euN2/W6qcl82NjYyAqNDQEkrVu3XHb1gNtWneEHD4+Y05OztTpXzs4OG3etOeLkd/AIywu7h0bBc+RRYtnZWVlwRm/X7TCw8Nz5qwJ8JSBqGNHLsPfbyfPBjVqujlEF8BCwj/CcQTyYoDO5URRVEzM63VrtpqYmMDunTs35Wbn57V1/QJgd8zo8ZevnN+7d8c3X0/5+EArK+uvv5xcIBwq5fET//TrO6Rzpx6w275dlwcP7m7ZugEqX/PmrRYumhkd89rF2RWiLl066+npXbFipaKfVBWo1sYmJkOHjAYLDweCbYSWIYRXr17r94273d092LWxcnNyZsyakJScZG1lTRSiAisNaWAbhPf75nUhIU+dnJwPHvrLydF50EC50YOnD2gJGgUFznjh4pk3b2L/t/w3SA+7cHmf927HRsHd+239TlNTU2trG9gFC3nw0J77D+7Ary7izSFFRm4huW8jBfJiQHE8cBU8vFg1AlCHwIywwiAK1dWpXe/uvVtqD6xSufrHgc+ePc7Ozg7wf99lghyOHjsEkmjcqLmxsTEYyV6fD2AYBiwDbOh6UiWhoc8rk6zLIgAAEABJREFUVaoKamR3oeXJNj4h5PXrV7+sWfr4yQNoJ7OxiQnxrCCBqlVrsBuWllbwF2wm/I2KivT0qqjMXJlGFUgDN8rZ2YXdLVfO3tHRSRmbnp7228bVYOeVZvPjLreWm6O8PIEgkD5kcR6c0NFSbkPtBBvCdnuU2NjYqj8wf10NVdj6/fW44QXCE+LjwB42atjs4qWzoENoWKakJAe3aq/rSZWkpaWqTXP58vlZ303q32/oF6PGgfmFhvGUqV+pJlD7MSF0/MCoKndNTUzVpjH9sHFubJz3IIN277gJI+r61Z8983swv3CK4DYNPs5By83RRZA4hQdHoEpcVvDUh3bXooXLVQPFIrEOOdg7wN9JE2e6uZVXDXd0lDfzWrQIBh8J2BBo/tWo4cu2/Yp3UnNzi7T0tI/DoWdbq1adEcO/ZHdZDRQKNL8zszKVu+nqcoY0GRnpqiHKZOfOnwTTBx1I+CFEnW1k0X5zigrFh7c/BCFIusRv6lSsWDkjIwPqB+uWBGDg0cbatug5uLt5GCtMLutjBMCtAg1UMzO5bQG/Dnh3wMcIDsmB+V7K4p20SpXqf/+zF5yWbF8RfKRHjx788YdVYMecnVyUyVTdSFoAP/OVfy/QNM2uOfnv1Ysfp4FswXkD7h9wz8JuSMizd+/eslFwUmgAs2oENPlptN+cIiKi+DCFB74YUCTq1a1fv36jn39eAG2wpKTEAwf/Gj1m4LFjhyCqvIcn/D137uSjxw+05AB1a8jgL8BRAY1SMBpQNSdPGat8nQX6io0aNT90aA9k3qJ5q0JPqoUO7btC/suWfw+NUmgGb/htFdgf6ED6VKx8/cZVcMmAVv/as51NHBMbrT03MN1g1sC5CvKAYw8c2P1xGrhyaKX/vGwhyBKkOH/hdKv8dqa3dyUw+4f+lj8grv135dat/8C7AwMbRN6sNXZwcLyhuCQ4XMvNKSLg1GFownXwxYCiAsMbULGgtj16dB8GA1u1ate9ex8IB/MFXhNwS9asUXv5sl+15NCn9yAwejt2boZ6CQ3LGtV9J02apYxt0azVzJMTA/wb2NraFXpSLUCX74fFK0HG4BSBSg8u0xEj5H3FYcPGQkty1uyJYHW7d+sDzcjo6Khp07+ZOWOhltzgekZ/MQ6eFIGtAqAhPXP6wm/Gjyiw/ISFhQUMaaxfv7Jj5+bg3Rk18ptTp4+yUUGBbSIiQkFpy1cshqymTpkLgyI7/twM/eSJE2b07zcM7tt/16/8ueMf7TdHOAhibY8n15NP7ngzZC4u7MFn9q2KEIuoATM8CJcRhlOH4cXsDohWGBmjdoU/biGMz68ohi8fA8iBJt+ff25WG1XB03v1yk1EkCgKGF8MQMqcTp16tGzZWm2URCzcAsWJkjkDRfHJQBJLC0v4R5APwYmSuQOD87LyHzG4dNBCcgL5FB6oSL4jf3sBLSSCGAj8GL9DQSKIAYGCRBADQjifX+E0kDxHIsEZAziC4lMP9OrwnNxcRoxeVgRBShEUJIIYEMLoQ4ppiRS//OQ5UhORmMLFdriAR2VjGDUmCK/JSMk2s+J8J1IQgjS1MDUxpS7sjSYIf8nJJEF9HQjHEUpDrvNYp7CHadnZ2QThI1u/D3HxNrawNiUcRxAzBrDIZLK1k8Ps3KQePma2zqYFXm+lqILvXlGK/z6+PapjmkUZ32Tys9eUQF4Gal/CpJTLAlOaIjUdm/9zNB8L0Rrf/GS0Xq/6Qwpkl3d5iusjai5Pnv7jU2ganlL8GjUxmek5r56lxURk+Ley9W9VjnAfAQmSZceP4ckJuXQuobm/uKcWKKqwdzs1D80WY9BW4yGaIjSE63pqiZQYmYp8m1r5t7InvEBwghQOPXr0WLp0qaenJ0G4A45D8hbl1KwIh8AC4y0oSC6CBcZbUJBcBAuMt6AguQgWGG9BQXIRLDDegoLkIlhgvAUFyUWwwPgJDC/LZDIUJOfAAuMnaB45CpYZP0FBchQsM36CguQoWGb8BAXJUbDM+ElOTo5UKiUI10BB8hO0kBwFy4yfoCA5CpYZP0FBchQsM36CfUiOgoLkJ2ghOQqWGT9BQXIULDN+goLkKFhm/AQFyVGwzPgJCpKjYJnxExQkR8Ey4ycikcjNzY0gXAMFyU9omo6KiiII10BB8hNor0KrlSBcAwXJT1CQHAUFyU9QkBwFBclPUJAcBQXJT1CQHAUFyU9QkBwFBclPUJAcBQXJT1CQHAUFyU9QkBwFBclPUJAcBQXJT1CQHAUFyU9QkBwFBclPUJAcBQXJT1CQHAUFyU9QkBxFRBA+IhaLaZpmGIYgnILCMuMZderUEYlEFJVXsrAByuzYseOCBQsIYvCgheQblSpVYgUpUgAbbm5uw4YNIwgXQEHyjaZNmxZo9dStW9fLy4sgXAAFyTcGDBjg4eGh3HVwcOjXrx9BOAIKkm/Y2dm1bdsWWqrsbo0aNapWrUoQjoCC5CH9+/cvX748bFhbWw8aNIgg3AHHIYvKq+fpmem00vIADGFE4KYmKgGEIhp3C4ZQBLp6FNF6gHyfKRhAUwz8r2AggSAqf5fq0HL4kX8Oe/v4mJOKL+6lFcwSrpopeKqSoPpbqPwfopP7XiyWedawIoIHhz0K58C6V9GhmVC/ZAVG2tUIqGSUJEN1x2rKT2M4qErDBWiJKhXEEkIzxMKKGvxdRSJgUJCFcPSP15FP0wPa2fn42hFEn2RkZJ/ZEZUQKxvzow8RKihIbexcFpGWlNtroqCf2WXMjVNvHl9LHvuTQDWJTh2NyGSyuKgcVGMZ49/K0dhE9M9Gga6DgE4djZzfHWtkQpCyx85FGvsygwgStJAaSU8lIpGYIGWOmYWRLEugNRMtpEZyc5mcbOxgfwJoGcnNEeidR0EiiAGBgtSKPkfeEI0wRMfXCvgDClIj8m+XCPIJoESEEuqzEAWpEcUX9wQpe+C2C/bGoyARxIBAQWpE/rU9jgp9CuSTHQh1vAkFqRF5i5UmSNnDQG9BRoQJClIbFHp1kLIFBakNdOogZQwKEjE4KDH2IZGPkI+GYZP1kyATbh8S3YgaYRiqhMNhZ8+dbBnkn5iYQIpFl25BW7b+9nE4ZAjZQuaEpwi5o4AWUjOf+tvt3r0GVq9WiyBCAgVpuPTrO4QIExgApvBdVqQ0WPfr/06cPGxmahYU1NbdvYIyPDc3d+OmNVevXXrzJqZmzTrduvRq0KAJGyWTyf7as/2PLethG0zikMFf1KpVhyiarD269x00cARsnz5z/Pff1yanJDdq1Kz35wNVz/jw4T049smTh9Y2tg0bNB08aJS5ubn2i5wzd4pYLHZyctm5a8u8uT81axqoKRNIAOFHD19iD4yNjenTr+PC+UsbN26ekpry++Z1165eSkiMr1K5eqtW7Tq078omO3b870N/7w0LC/Hy8gls2Rp+BaVLd1z00Xx8wgH7kBophlPn4KE9Bw/9Ne6bqWvWbHFxcduydYMyauWqn/bs3dGta+8d2/9u3ixozrwp5y+cZqPWb1h18OBf8+f9PGvGIgcHp6nTv375Mlw129DQkEXfz2rduuO2rQfatO64avUSZdSrqMjJU8ZmZmWuXvX7gnk/h4Y+nzBxVKEL0Uml0tCwEPi3aMEy31p+xcvkp5/mPXp4b/z46Zs37alWrebyFYtB1RB+6vSxH3+aV7lS1R3bDo0Y/iX86tVrlhJdoBnhDjihhdQMo7N7Yd/+nc2btQK9wXbbNp0eP37w6tVL2M7Kyjp+4h9ognbu1AN227fr8uDBXZArpExKTtr917bx46YF+DeAqM8+a5yenhYX/87Dw1OZLYjcydGZNZV+dfzj4+Nu37nBRp06dVQqkYKKrK1tYHfypNl9+3e6dPlci+attFwn2KuYmNfr1mw1MZFPUnLg4F/FyOTuvVt9eg9iL3vUyK+bN29lbSU//MiRA76+fvCLYNvW1m7o4NE//Tx/QL9hsE2QwkALqRlKt2+AwAcUFRXp6emtDKlcuRq78ezZ4+zs7AD/hsqoOrXrgd0DNYaHvYDdqlVrsOESiWT+vCWgOtWc5dl6vZ9rS5mYyNurd2GXFRLg7Ozi6up+7/5tUhgVPLxYNRY7E2hXw6Nk7boVV65cyMnJqVK5GhxI0/SDh3dVf6mfXwAEFuWSEIIWUguMjuudZmRkQG/Q1NRMGWJiYspupKamwN+vxw0vcEhCfBwbZWKsbTqt5OQkd/f36+eY5mfL5vzk6SMYBSmQLSkMI2PjEmYydcrcQ4f2nDl7HGRpYW7RrVvvQQNHQkMXxAm9Zfj3QW4J8aTIyDsL+GIAUkJMTU3BU5KVlakMychIZzfK2TvA30kTZ7q5lVc9xNHRmR2lhGaqlpytrKwzVbJVTWxXzh4s1dAho1XTs03HolP0TGQqA/ZWllYD+g/r328oNL8vXjq7ddtGCwvLXp8PMDMzax3coZmi3a7E1cWd6IRQX+tHQWpE18+voGMGfku5Y+PzvBDwqbIb7m4exgqLpGyLgsUA+wt118enCjRToT8GfhGiaPdOnzm+ZfPgNm06KnOGbK/8ewEafiKR/IL+vXpRGVXRuxI4dWv71mWjgPDwUFVzWhS0ZCKVGkEHGOweXCTsvowIYxNAY/v06WPQGYZ2L4gZ/oWEPH32/Ik8t4qVwQGr/KVgMKOjoxwdnUiRYWjhOnWwD6kRRvfPr1q2CL5w8Qz7Ds2fO/949Og+Gw7Cg8EM8OLcv38HOpPgXwWv5or//QBRFhYWwa3ag5f16LFD4KoBD+rNm9dYcSpp0SIYDClEgVwhzYEDu5VRPXv2B6GCGzMzMzMyMuLX9SuHjegN7lOiC1oyqV69FpwUhjGIYsxjx87N7CESsQSGQ+bOnwrmEZxMJ04cfh7ypFZN+WjNyOFfXb587sjRg5An/N75C6ZPnDwafjVBigBaSI1QIkrXYY8B/YezyoFaCEZj7JiJMFzB9kTBIQmmAyr0rVv/mZtb1KjuO2nSLPYoGCYBcS5dtgi6oD4VK8+fu0TVxQqAJ3P0F+OgwxbYKsDJyXnm9IXfjB/BZgvtxo2/7dq5848vxgyAwRLwzXw7eTYMORBd0JJJtao1xowev379Srg8EOeoEV+PnzgKTg2jlHCdq35ZwnaMvbwqjv5ifLu2nYnC2bN+3fbtO34HYWdmZsAvXbhgmbFKlxXRAq7toZEDa6NiwrP6z/AmSNlyaX9s2P3UsUuFuIgDWkiNyM0jfu3xKYC2CX5+hRSEYTj83UGnzi00RU2dOrdJ4xbEgIHeO07hgRQEPI7cneRq/fodmqJsbfCNGcMFBakRmibcneTKxdmVIBwEBakZSrDTZyOfDBSkZoQ8gTbyiUBBagTn1PlUiMSUWIpreyAFQAP5iaBljAzXh0QKAKNhYrSQSNmCgtSI/DmNSwkgZQsKEkEMCBQkghgQKEgEMSBQkBoRiYhUSpBPgJgRSQXqZcUPlDViYSumaRz4+CgJQZQAABAASURBVARkpMiMTARaM1GQGgns5ZydxeCn7mVP3OsMlwpGRJCgILXh4mW8b0UkQcqQ03+9pGnSbqiOk2LxBZwxoBAuHXz74EpS9YZWfi0dCaJPXr1IuXnsXVYmM3y+cGdpQEEWzvGtUeEPM3JzFLOhFZaYYghT2Ps98pUrqGLnwGiayEBeluryVZuh2sTUx59kf3S2j3MrmJXGC1SXfz5iiTwbGwdJ/6meRMCgIIuKTCaLj8lWzuALNbDAnWNDKEb+P9hdunSpfblyg4cMeZ9AUZlJgXqpmlHe9sd5v49V6iE/k/eZKU9d4BTyUNFH67MzisspcBWKJ4VqOhFFCji28i/g/UUWuFyRYlLVZ0+fLF++YvHixbZ2tu9/n+pVfXiUkZhYOwm036gKCrKUyc3NDQ8P9/HxuXr1aoMGDYiAefv27bt376pVqxYREVGhQgWCFAF06pQmT548ady4MbuQm8DVCDg4OIAaYePbb7/dtWsXQYoACrJ0uHXrFlEs73Ht2jUXFxeCqLB7924QJ2w8ePCAIFpBQZYC06ZNO3lSPlu5n58fQdQRGBgIf+Pj43v37g2PLYJoAPuQxSczMzM0NLR69eq3b99GKRaRkJAQiUTi7OwMd8/GRrdFgYQAWshi8vz586CgICsrK4KGURfA3eXp6Qma7NGjx+nTpwnyIShInQH3KVEs6nT58mV3d4G+UFJCQJBKNYInjCD5oCB1Y/r06WfOnCHyZaGqE6RkQBODyNdvfjhq1CgYLiII9iGLSHp6OjzI69atC37CmjVrEqRUuXnzpoeHh1gstrMT+qzqaCELJywsrE2bNvb29rCNatQH9erVg3ERaMf6+/uDh4wIGBSkNs6dO0cUL99cvHgRHuEE0SfgIbtx40ZcXBxR+MyIIEFBamTWrFmXLsnXJK9UqRJByopWrVrBX3D5TJkyhQgP7EMWJDk5GTqKjRo1goc0SvETApps2rRpfHw8DFoSwYAW8gNevnzZpUsXV1f50lGoxk8L+GCNjIwoioIN6MYTYYCCzOP48eNE/okSc/bsWRi5Johh4OTktHfvXlaQr169InwHm6xy5s6dKxKJvvvuO4IYMLNnz7a0tOR331LQgoT+yZ07dwIDA8PDw9EqcoK///67U6dOYCr5+o6UcJusr1+/7t27t5eXF2yjGrkCqJEo3tPo3r17bGws4R1CtJCHDh3q0KHDmzdv8MNF7hIREREZGdmkSRNo5vDp/R7BWchFixbdvn1bLBajGjlNhQoVQI1EMR3B9u3bCV8QioV8+/btzZs327ZtGxUV5ebmRhAeAW7YHj168GPmHkFYSGidDhw40MfHB7ZRjfwD1EgUz9yhQ4empqYSLsNzCwnPzvbt26elpbGvhiP85t69e9nZ2f7+/jRNwzgW4SB8tpC//PILlJCpqSmqUSD4+vqCGmHjyy+/5Kip5PNydEOGDGFnZESEhkQiSUxMtLCwIFwD39RBEAOCz03Wfv36PX36lCDCIzY2lqPrCOLL5QgPmT59+uPHjwkH4XMfcseOHQQRJC4uLtCNJBwE+5AIYkBgHxLhIe/evcvMzCQcBPuQCA/5/vvvr127RjgI9iERHuLk5GRsbEw4CPYhEcSAwD4kwkPi4+PT0tIIB8E+JMJDVq9eferUKcJBsA+J8BB7e3tTU1PCQbAPiSAGBPYhER6SmJiYkpJCOAj2IREesmXLln379hEOgn1IhIeUK1fOxMSEcBDsQyL8oX379vA3OzubpulcBbBtZWXFLnrNCbAPifCHSpUqRUdHQwcyOTk5PT0d1Aj2pkGDBoQ7YB8S4Q8jR44sMH8S7Pbp04dwBz4LEvqQVapUIYhgqFmzZr169QqE+Pr6Eu6AFhLhFaNGjXJycmK3ra2tuWUeCfYhEZ7h7e3dqFEjdhu6lAEBAYRToIVE+MbgwYNdXV3BPPbv359wDRz2QEqB3Usj4mNzaJrIZNqSUYRor23y6khRJcmh0EMohjBUYccwisNKngYsHkUoMTGzFLcd4uDsUfg8sShIpKRsmBFiaiGpVNfa2dv8g6qvqgRF9c0PoRQbjLpkijpOMcpAqJ6qCqVoESOi1Z+CDflIb2oEyRRoGsIZCsiAyhcck3dVVMGrVT2RFpFDcFJc6rMbaTFhWcPmeJhZGxGt8FmQ0IecM2cOOlr1yq9TQyr4mjbuiEsYFc72RSGBfR0r+1lpSYN9SKT47Fn50thCjGosIj5+Fuf+eqM9DY5DIsUnPianQg0zghSNz9o752aTuNgMLWnQQiLFR5bL2Npz8h3uT4VIRL16rm2NAxyHRIqPLAc8HEVwNSL55OYwjFZHNJ8/v0IQzoHfQyJIWUJpb1GghUSKD0XJR/AIogOF3C7sQyLFh5GPYmMfUle0aRItJIKUKdofYdiHRIoPJYImK46c6QCj/KMBtJBI8WFkDGFoghQZRa9bG9iHREoAVYQvJxBVCut1o4VEkLKEoQTbZMU+ZJmAwx46QaGFRPQKtll1gBIRkUjbIwz7kEgJoAgKUifABUbT2u4Y+qyRkkAxem6y7t23Myi4PuER2vuQ+D0kUgIYvTtZq1erOXDACHZ7/4Hdi3+cQzgO9iERDlOtWk34x24/ffqIcB8ch0T0SlGbrKmpqS2D/O/evcXunjp9DHbB6LG7L1+Gw+6jxw/mzJ0yf8H0X9evhN0LF88om6zjJ446fuKfEycOQ/iz508g5OHDe1OmftW5S8uBg7uvWbs8LS2t0GuYN38aZH7lyoXOXQOD2zQYN2Hk48cPlLHHjv899qsh7To0gb979u5gp5vq3rP1H1s2sAmSkhLh7JCJ8pCevdpevXqJ6AJDCbXJipQJRW20WlhYODo6PXx0j9198OCOk5Pzo/zd+w/uWJhbVK1SXSqVhoaFwL9FC5b51vJTHr5i2Xowla1bdzh7+kblSlVfRUVOnjI2Mytz9arfF8z7OTT0+YSJo3Jzc7Vfg0QigQs4eerIurVbjx6+ZGxkrGwDwwPix5/mQc47th0aMfxLEOTqNUsh3N+/waPH99k0t25fh2uGS2V3o16/iot75+lZkegEI1SnDvYh9Y3iRTAdqpBfnQClRbp771bbNp3gL7t7//4dqPoikQiyjIl5PW/OT40aNbOxsdWU1alTR6USKUjRw8PT09N78qTZz0OeXrp8jhRGRnr6t5O/c3VxA3EGBbaNjIxIT0+H8CNHDvj6+o0fN83W1q6uX8DQwaMPHNidkBAP2/DsYK3l3bs3WzQPTk1NASkqrvk2XKGzswvRAYZCC4noCYahdZpGFCr3vfu3iaLtFx4e2rlTT7AwsbExRGEh69bN86ZW8PAqdLnVhw/vVq1aw9raht0FVbi6urOZa6e8h6eZWd7EXBYWlvA3JSWZpukHD+8G+DdUJvPzC4BAyLBe3c9AsWFhL9iLrFWzDpz3wX25kYSHSL26unqAKe2OMD47dXBeVv3zfgbholCv3mfJyUnQXYQWaSWfKnZ25apXr3Xv3q369Ru9fv2qfkDemhxGxsaFZgVm6snTR9CjUw1MiI8r9EAwwh8HZmdn5+TkbNy0Bv59kGFCvIODY/nyFUCu5crZgyxBqI+fPABltmnTEeTap/cgoiM4YwCiNwr7dqEAUKe9vCpCLy7kxbNavvL+IfQSYVckFkMbErpnRc/Krpx9rVp1hg4ZrRpobWVDigUYZDCbrYM7NGsWpBru6uIOf8EMQjcSWqfe3j6QrFYtv7XrloORf/XqZcMGTYnO4LusiJ7QfcYAsDDgaAUfzIABw2EXWoDrf1sFzhjoQOqUT0XvSidOHq7tW1dp8aAN7O7uQYpLxYqVU1JT/OrkmVwwmNHRUeCFgm1oS69du9zC3LJ27XrsNYORh04sdF/ByBMd0X7HsA+JlAwdXw2oWwcEeVNuIWvWIfIFVetERITdvHmtbhE6Y25u5cEnBK5OaEn27Nkf+njgCM3MzATHDAyTDBvRG1rCpLiMHP7V5cvnjhw9CNlC5xBGRyZOHg1NWaLwRcXERv/774WaNWrDLhhJaG/v278TWuCktMFxSKRkULp9oAzCg8oNvTJwZhLFWAj4SCEELGehx3bq0B3ayN9O+fJF6HMrS6uNv+0yNTH9YsyAQUN63Ll789vJs2HQghQXaACvX7f93r3b3XoEw4BKWlrqwgXLjBW9WbjIKlWqv46Oqpt/kTVq+Kru6gBDtPe6cbEdpPisnhDSuJujT20rghSNP+aGNOnqUKe5taYE2IdESgBDcMoAXUEvK6Iv5JNcGZgep88czw4Sfkz79l3HjB5PPiny5qjWO4bjkEjxYQhtaFNczZ75vYxWv3qGVCIlnxqKEO19RLSQSAlgDG7mcuVbOBwF+5BISWCwD6kTOC8rokfkg/IUDmXrAKX8owEch0SKD03Dw15GkNIDLSRSAuQ+VmyylibYh0RKgNxjiPOy6oDi3V/sQyL6gTK4YUhDR+GVxj4koh8YHr94+YlAC4mUAHx1rrTBPiRSfCgJJRLhcnQ6IBIX8qoOWkik+IjFTFpKDkGKDIjRylFbAuxDIsXHwlry8nE6QYrGs9tJYCG9q2ubZwRfs0CKT/sR9nHR2QQpGrdOva1Q1VR7Gj5/oIyUAdHhGftWR9VsbFs3UOfZZYTD69DU0ztiajezatzJUXtKFCRSUsIfppzYFpuTQyRSKvcje8muWJf3BgH1PpBhB+Xyax87oCkfN6c+8Hqwu8pYQgom+DAk7xxqM8nfYNjZ8tj5uRiiJk9KJF837n3sh1dLvX9HnFK98gI/hEUK94SmKYa4VzHuNKI8KQycwgMpHV7cT4oOy6bVuHjyKjDzwVt2VH6ASkVmVOt/wcM/TsAwVP4s4AVPERMTGx8fX716tXwxv8+Tef+GN/PRI+KDcyofBB8eqNyFAR9NQz4qaUXE0p7ya2pPigZ6WZHSoWIt64q1iIFw8OCVN3F3R/doRrgGjkMiPCQ3N1ci4WTdRguJ8BDuChLHIREeghYSQQwIFKQhgn1IwYKCRBADIicnRyr99JM+FgPsQyI8hLuCRAuJ8BBsshoi2IcULChIBDEgcBzSEME+pGBBC4kgBgQ6dQwR7EMKFrSQCGJAYB/SEME+pGBBC4kgBgQK0hDBPqRgQUEiiAGBfUhDBPuQggUtJIIYEChIQwT7kIIFXwxAEAMC+5CGyKRJk54/f04Q4eHs7GxkZEQ4CJ8tZFxcHDwpCSI8Xr9+zdGi57MgN2/eTBBBAu1VjgqSz01WmqZx5RJhgoI0RL7++utr164RRHhwV5B8brJCtx6MJEGEBwrSEFm+fDlBBAkIUiaTEQ6CfUiEh4jFYuxDGhyzZ88+fvw4QYQHNlkNEexDChYUpCEyZ84cgggSHPYwRLAPKVhQkIbI0qVLd+3aRRDhgU1WQwT7kIJFKpXm5OQQDsJnQY4bN44gggSbrIYI9iEFCwrSENm0adO6desIIjxQkIYIdCTQQgoT7go1YsfxAAAQAElEQVSS4l+V7dKlC3Toob0qUkBRFOvaOXz4MEF4TYcOHdiyTktLg6I3NzeHbajhR44cIRyBh04dDw+Py5cvQ3koQ6CQ/Pz8CMJ33N3dr1+/riz61NRUKPrPPvuMcAceNlmHDh3q6uqqGmJpadm7d2+C8J3Bgwc7ODiohlhYWPTv359wBx4Ksm7durVq1VINAZvZunVrgvCdRo0aVa9eXTXE09OzSZMmhDvw06kzcOBAZ2dndtvY2LhXr14EEQaDBg2ytbVlt6EPOWDAAMIp+ClIeEzWq1eP3Ybma6dOnQgiDMBZoCx66FJyrmXE22EPeDSCkQT3N5pHocEWvZGRUc+ePQnXKGTYI/JZ+oV9b9OTc7OzPjwMvMnshjwDSrEB/uW8v4oEjCLuo/PBgRQD/71Pmb+hyJL6MIR8nPMHuX0USCmujFFkxTA0xCp9biKK0Iyaw8UiIlP/xqv8Kj+4kvyLL3Bq9RcsUlwJU0ieyl+tRGrMSKQi98omrfu7EoPnwLrIt6+y6BxKOeyn9m6wQFGovlxcMKWyUsnrFFXgRB9nS9OKavRRAnmUTF7UYrGIUVQEtsgKnKVQ8usS0X4lJP+a5RVeQ1aQjbEJZW4t6vyFs4W1KdFyUi2CfHoz+dSON7bORo7ljQkj0nguQqm9AkpdeH5ipsg5EQpkBWJSeyfVHgKioRi1ORW5LNi8Nf2EQlPKT6RQHl3g+tgni3bgtyYn5byNTDc1Fw+Y7kUMmF+nhUhNRA7uRmZWJoxMeW8LlMr72654GL0vAvYx+z6h/C4yasI1UJSbWVR0y0tNRco/Xv1lK0wD/TYyM+Ft7ufj3Jw8NGpSoyBP/hnz7GbqoNk+BPlEHFgTlp3BDJ/vTQySdVNCqgRY+bd2JIgubF0YUr+djX+gvdpYjX1IUGP/GQb9eOY9Xcd6USLq4PpXxPDYsjDMztUY1VgMmvZ0uH40UVOsekEe3vjK1IwSi8UE+aR4VjONCc8khkdKgqxRF3uC6I5nVWtKTC7ui1Ubq16QcLulprhS3afHtaKVLLu0+kmlxusXmeCysrYzJUixMDIRx8Wof/ddveqyMsBDaXD1QICIJJQs1+De/pcxjIyTn+MbCrlZJDtDvWcfzSCCGBAoSAMH2ynCAgVp4OAH1sICBWnQUBRFoY3kHeASo8TqyxUFadgwDNpIHsIQSsMLOShIg4ahDFGPFPZsS4b8PToNEwajIA0bxhCrPlpt/aFekOyXCsinB0uBj4hElFiDKVQfzNAUzp9oEFCGWAyUQdptDkHTjEzDJJVaPqpCDACDrPmMQT4mOAR4zjU5z7EPadhgzecjjJov1/NAQSKIAWGgc+qEhoa0DPK/f/8OKSu6dAvasvU3/aUvHob5WoAhXFPX7q3K4P7rCZGIiDS8GMDntT10onevgb61CpndvFuP4NfRUUVPX3IMc6EHbEeXEBiEpGX4YoBW+vUdoj1BTEx0YmJC0dMjSDEoNQsZFvbifyt/HDy0Z5t2jb4YPeDgoT3KqI6dm+/4c/OcuVOgFQrb02eOT0lNgfBnz59AyIWLZ4aP7AMbPXu1/WXNsgLZ/r55XfuOTVVXMtq798/gNg2SU5K1X8+x43+P/WpIuw5N4O+evTtYU3Py5JGg4PohIc/YNI8eP2AvgKg0QSElpB85ql/b9o3hh2z4bbVMJrt950bf/vLJXfsP6DLru0mq6fcf2N29Z+uXL8OHDu8FucFvgVMrL+PQ33sHDOzauWvg9z98FxsbAwlOnzlOigyf3mXdt3/XlKlfdercosfnbeYvmB71Om9qkpmzJ86dNxUKGmoOlCzcc2UBaYliycjIgCLetn2TMgQKC+72r+tXarkS7UX28OE9uM7OXVoOHNx9zdrlaWlpELhg4YyJk0Yr00A9hwqg3IXYaTN0WB1Y7mXVoLxSE+Qva5Zev/7vuG+m/rB4Zfv2XUGcV69dZqPEYslfe7Z37Nj9zKnrP/2wGm7EqtVLIFyiGBzdtm3jwgXLjh+98uXYSQcP/XX4yAHVbDt17AE3/eKls8qQ8xdPN2ncwsrSSsvFnDp97Mef5lWuVHXHtkMjhn8JAlu9ZimEBwe3r1e3/tJlC4lCeLDRKqhts6aBqsfu27cTCrhnj347d/zTqVMPuJ6du7b41fFfvGgFxG7fdnDh/KWq6aVSaWpqyspVP307aTb8wObNWv20ZD5oD6IeP3m4fMXi5s1bbf1jX4tmreYvnE4IUV0FqFC0uOO4BbgDoNBr1Kg9f/7P06bOS0iIX/T9LDYKqgE872Dj2JHLf2zea1fOftZ3E0FX2qNYTE1NW7Zofer0UWUIpE9JSW7bRtvU2FqK7FVU5OQpYzOzMlev+n3BvJ9DQ59PmDgK7EHduvUfP3nAnhouPjY2Wp741cu8X/fgjn89HZb0kZcqo0sfUrGIG9GJ2bMXL1mypq5fANTdLp17Vqlc7b/rV5SxPhUrB/g3gEyrV68FsefOnVQuAd+0aaCLs6uRkVHLFsEBAQ1Pnz6mmq29vQMceCbfqsTFvYOibR3cQfvFHDlywNfXb/y4aba2dnBJQwePPnBgN9xHiJo0cVZY+IsjRw8eOPhXfHzcuG+mFTj27r1bVapUb9Omo42NbccO3X5Zvfmz+o21nw5+y+BBo+CnwQ9s07oj3OyQkKcQfuLEP3Z25YYOGW1tbdOoUTP4IURnDPLFAJHOZhtuzu8bd/fvNxSqB9yHXp8PePz4QVJyEhubnZ01cMAIuHuuLm5wu0AbSn+eliiWDu27RkSEPVfccOD8+VNVq1SvUKGQ+dk0FdmpU0elEilI0cPD09PTe/Kk2ZDzpcvn/Os1yMzMDA0LgTR37t709q4ENRyqClH0Zd6+fVOvri5rbDGUpgethqd1MV4fZhiwLYOG9IA2APx78vRRokIALD4+VZTbbq7l4Xa8zm+xVPowKjwitEDGYG+vXrvEFt6586egctev34hohqbpBw/vBvg3VIb4+QVA4L37t2Hbycl52NAx6zes2rRpzdQpcy0sLAocXrNm7Zs3r8EjE5oxcFI3V3cfn8qkMKpWrcFuWCpMd6qiTQ7lV61aTYkkr6PerGkQ4QcynR8TYrEYSnz6jHHQZ4HqMWPWBAhU1hAvLx/lXXJ384C/ES/DCo1iqVHD193dA4REFK2e8xdOBxf2vGZRW2QPH96FcKhjbJSzs4urqzvUHKg2sME+C8Ae1qxRG0oWGrewe+/erXLl7L28KpLSQL0gwQVE63LPobpDG/r2nesjR3x16ODZs6dvQLVWTWBsbKLcNjGVT46Ulpaat2vyfq4kExMTZbgSaKCam1vAkw+2L1w8DeZR+3R42dnZIPiNm9awjwb417uvvIQS8ou/e7c+8NyFR6NaNyk0VsG0JiTGQ6O35+dtFi2e/e7dW1IYalsUUMampmbKXWUxc51ifINy+fJ56BBC02PFsg3ynsuPq1VjTVSrh4l8+3310BylpGvnz0+cPAxqhPZqRkZ6q1btSBHQVGTXb1xV1hz4B8+RhPg4iIKmFsgVNu7evQntr5o167CPePgLT3xSSpSOlxXcM0+ePPx5yRroobEh8MMc7N9P2ql6EzMzMoiKDtknU15UZqaqPvMuUSJp17bzyVNHmjcLunfv9rivpxKtQLGZmZmBbps1+8Aiubq4sxvQJ3RxcQPRrt+wErRX4HDo40FLFf6Fh4feuvXf5i3r4eK/X7ic6A48hnJz3s8GFRf/jugIVYqTc39S/jmyv1atOtCfZ3dVC50UqB6Z8mkvlU9wLVFKglt3WLf+fzduXvv36sVGDZtp9y9oB7qpcJ3QNlYNtLaSP0nr1fvs11//l5SUCIPkdf3qszYfdsFg9uszhOiCfBxSQ9u0dAQJlwV/lQqEqgz/vDzfG3F4qCi3oVEOGnNzKx8VFUkULfImTVqwUdCO9/ZSM1d6hw7dQEW7/9oGfhpv78InU69YsTI4cqG7wu6C9qKjoxwdndhr+2PL+pX/2whS+Wb8CNAtdCRUjz1+/J/KlatBCwS6EPAP8jl8ZD8pFvAbnz9/oty9fPkc0RGG8MSpk5yc5Ozkoty9qPBsK3kR+hyqENuCePbsMfxVlrKWKCWgwBbNW0EbCjp7kyfOIiWgonclMLa1fesqfW9QYaBJDBtQnWJio8FJXrFiJXjiQwgYfGgqg5PSX0fvgLxIKX2+GOBZwRs0tmv3VhiNYJ2o0HGPUXiiWN6+ewOOVnBSQew/h/e1bNna2NiYjbp+499r/8ndP3A3ocmhtr3h7la+Tu16e/f9Cf3vIlwOGTn8K6j94LmBtjS0+8HJPnHyaGjKwu7C72e2CmpXrWoNeBAGBbaB0QjVMRXg9Jlj38399sqVC9CBvHr10sVLZ6DDAOHlPTzhL7ijYLCEFI3GjZqDvwGGfKA1BQ2h4rx4ZJDmsRhGG7x6cAegfOFuQ01gA5U1xMrKGnyeUHng35atG6DDpuxNaIlSBRwNrK+1QYMSLc/as2d/qCTgkwdrHBkZAcMnw0b0Zn058FAAe7B37w62PgCwsW//TnhAQB9Sl5MQRvOLAaUjSLhNM2csfPT4fpeugdBfh5ZJ5849wY0GwzVsAmgBQg+4VevPIKSCh9fXX32rPBbM/caNv0BjHQYqu3fvA04ztacALyXoOSiobREuh4DY1q/bDu3bbj2CwYsNzR4YWYFHwPYdv8fGRI8ZM4FN9tWXkxMS4rZu++ANLHDDwvMFOjxduwUtWboARDVxwkwidzi5gzMdxsQ2bFhFigYMqHTr2gsMMlzG/gO7Roz4iih87oTjFMNoDxs29rP6jWbNnti6bUPwlMLIB/hCp03/5pTCqQ7NIk/Pir16t4P6ExPzeuH8ZUo3gZYoVcB8gUkIbtVe6QEqHmBsN/62y9TE9IsxA8BDCc23byfPBh3mncUv4HV0VK38JwL4k2DXr06pdSCJpsV2/lgQztBUj/EVSGkAQ6g9uvcdNHBEgXBoi8OY7P+Wb4AucqGZTJ85HrxhM6bNJ9wBrAE0eJROWhiWHPvl4A2/7iiK25YlOizj+Oaor1cY1pJHkSEZB1ZHDZlXOlcFD2LoUi79ea1OUQV4+uzxmLGDtmzeyzYvDZw/fwizsZf0mlT+4yhDf3UuNTX1eciT27evP3xwd9PG3YRTQHd/4qTRXbt83rvXoPj4d9D0gmcq9EB0yQMnnSuEkJBnMEy//rdVffsM5oQaiWJGDv06dfRHREQo1GkHB8d585bY2zsowzt1bqHpkKlT58JICTEAoB01aeLMo8cODRvRy8LCEgaXR48er9MrF5RBTihlUA8JcJVD7zQ4uD0MLysDod/+55+b1aav4Om9euUm8knRMpeg+ibr1kURjIzqNs5wnzdxcRqHEKBla2RkRHiBYTZZX73I2L+q1Jqs+iA9PR0GJNVGQSfzkw8IF6fJauAzi+nq10JKEcMfiTFTQDiIhjd1aMP8EE+AYB+Sp+CcOpzEp/Z8TgAADzRJREFUIGf/w2dEKYBz6nASg2ynYONJf6AgDRy0RjwExjzEElxsh4OgLeIlNE00LYyNgjRoRIb5gTKa7ZIhv4Ho1OEihmkh0QNfQuQ3EJ06CGL4aBYkPgYNAJHYENuHFJFhq7VEUDRF6fL5lYk5JebJy2fcJi0xW2x4X2uJjcUibFqVAHCxmlqpn4ZGvSCdvYwzUjSsl4WUIeGPU4xMDM4YuZQ3FVHk+e04ghSL7Azas7qp2ij1gmzezRkM6r2LOs8Bg5Qu0S8y67SwJoYHPLLvnE8miO6c++uV1ERUs5Gd2liNMwaMmOd191zizTOoyU9Ddnb2tkUhNRpa1ws0xNfou44pb+9stPPHEILowqk/I1+/yBqxwFtTAkrLW+RQJzbPfUnTlLEplZujreEkoig6Px9KMQesakh+eMFziUTy4RgaRkkLXBOl5qrYqZtl6q6W+siHDDkzim/OmMKuVmMWmi+JzVyZgZrcPjyRWEzJZEzh15CPVAp3m85Mp6t/ZhnY24kYMDuXRMTF5BibURKpOCf7gwrAwjB5i5OyIey3oO/vHSO/mar3QXmf1d60vASEJoppv5WJ5ZnQBQuUUtRt1YITiygZraZOKg9nd5V1QVlGipMylIpY8lJSeT+QfBRV4LIhK5GYycyQSY2oEQu0zeBKFfpZx/WT7yKfZWSmaUtGieTz9qhuq4bkX2hBxy2kgUBapi031UARQ6kVpPz+UQUTA1mZ2ZmZmVZWVoXmr/aMmhLIM6ff65cCfWqYxJY9Sm3d0nJGI1PK0lbaZoAz4QJvojOuHYnLTGHUCpItGhVBKsJUbkaB+6DUhlhM2BUD8jWiTE8pbj6jeqKPBZmVnQnmxNLCSvViRGKqwNRSrOSU15BXdZVXqwyn8h7ZyqxUU37wMGcUUcz7355/TygzC+JRw8yvWTmilcIFyV1OnTp18uTJH3/8kSAC49ChQ7dv354zZw7hGnz2Xufm5pZwDjKEo3C36FGQCA9BQRoiOTk5PJgEFSkG3C16tJAID0ELaYigIAULCtIQQUEKFu4WfaktaW6AYB9SsGAf0hBBCylY0EIaIihIwYKCNERQkIIFnTqGCApSsKAgDRF06ggWdOoYImghBQtaSEMEBSlYUJCGCApSsKAgDRHsQwoW7EMaImghBQtaSEMEBSlYZDIZCtLgQEEKFih6sVhMOAj2IREegn1IQwQtpGDBPqQhgoIULChIQwRKJS4O158QItnZ2cbGxoSD8Plrj+XLl69cuXLGjBkREREEEQZ//PHHZ5999vXXX7u7uxMOwmdBOjo67t27t3nz5hMmTJg5c2ZkZCRB+MuOHTuaNm2alJR0+fLloKAgwk34PHO5KseOHVu3bl3NmjVHjx7N0Wcnook9e/asWbOmQ4cOY8aMMTMzI1xGKIJkOXr0KMiydu3aX3zxhZubG0E4zsGDB0GKLVq0GDt2rLW1Ia7bpyvCEiTL4cOHf/311zp16oC1dHV1JQgHOXLkCEixfv36IEV7e0Ncsa94CFGQLCBLsJb16tUDa+ni4kIQjnDy5Mm1a9fWqFEDpMi/ghOuIFn+/vtvsJYBAQEgS2dnbqwAJ1jOnz8PVtHLywv6ihUqVCB8ROiCZDl06BDIEtzlIEsnJ4NeI1WYgOMUrCK4zcEq+vj4EP6CgnwPeAhAlg0bNgRZQtkTxAC4fv06WEVLS0uwitWqVSN8BwVZkAMHDoAsGzduDC4fPnkLOMedO3fAKlIUBVbR19eXCAMUpHr2798PLp9mzZqBtURZljEPHz4EKWZkZIAUwetGhAQKUhv79u0Da9m8eXOwlnZ2dgTRM8+ePQMpxsXFQQMV+g5EeKAgC2fv3r1gLQMDA0GWtra2BNED4eHh0FeMjIwEKULDhAgVFGRR2bNnD8gyODgYGrE2NjYEKSVevXoFVvHJkyfQQOXuO6ilBQpSN3bv3g2N2DZt2oAs+fGu1ifkzZs3IMVbt26BVWzbti1BUJDFY9euXSBLqEPQiLWysiKIjiQkJIAUL168CFLs3LkzQfJBQRYfkCU0Yjt06ADWEgbKCFIEUlNTQYrHjx8HKfbo0YMgH8Ln7yH1Te/evc+ePevm5tapU6elS5dCVSOIZrKyslasWAHPr/Lly586dQrVqBYUZEnp27fvuXPnXFxcoKotW7YsLS2NIB8CrTDwoLZs2bJcuXLnz5/v06cPQTSAgiwd+vXrB1XNycmpXbt2y5cvh0FtgijYsGFDQECAsbHxlStXBg4cSBCtoCBLk/79+1+4cMHBwQFGR6B5lpmZqRoL9fKHH34gfOTEiRMwYtGtWzfVQHZ6G5lMduPGjeHDhxOkCKAgS58BAwZcunQJmmdQR1euXMnKEiwntNxOnjx5+PBhwi/evXu3evXqpKSkqKgoNmT79u1NmjRhp7cBRzRBigx6WfULWIn169eD+2fz5s0ikfzx5+jouHHjRj59WTty5MibN2+yvw7GZqFGdezYEZyopqamBNERFGRZAOZC2XyFJlz16tXBhhBeAE2AHTt25ObmKkNOnz6Nr0wUGxRkWVCvXj2KopS7sN29e/fp06fD9ot7Kc9upSTE5uTmMDRDcrMZkYiiaUZhbyhCM3TeIeCrJFIJlZOrKC9GHikSQyiRJ6YoWlGOYrEIcoFtSl6weWcUiynIhU3AZs5eA+TJbivOJM8SYmEbAimqYMWQSimxlJhZS8pXNgtolfee/dWrV2fMmJGcnKyaEsaBDh48SJBigYLUO23atPl4AnUf1+bNqg8juca0jIgklEgiEktFchnImDzxsWpiWKWQPMmwUUpEckFCCCWiGFZmIhED4mPy079PxuRnk58DpfgvPzc2a/kfwhQ8nD0OlCyjZbk0I6NpmpiYi8pXlq7b983Hs91C2/W///4jSLFAQeodcOeYm5sTRWMV7ratqZevw1CJ2NTITOLgZWPnxr0377IzsqOfxGckZWZlZsem33kQ+yeRm1D5alMw+g+/0d7eHjrPBNEdFGQZkZqaCh2tf35NSIyRmTsYe/nxYfrJuJdJb0PjoaE78DtX1qkjkUg4ujCjgYCCLDvWzwilaapqcw/CL17ejU2OTe/4hZNnVXyht6SgIMuIDTNDxWZG3nX5OQFsRmrWiyuvh8zxsLAxIkgJQEGWBeumhJjZmHr48Xze14enwoIHOlSug2MexQff1NE7G2a9MLI04r0aAZ/Grie2vCVICUBB6pfDm6JkucTbXxAL+xibGls6mv467QVBigsKUr+E3c/waSCg1e8q1HaGUcqjm6MJUixQkHpky4IwialIYszndeM/xsHH9sU9/Ci0mKAg9UhyvMzTgN2qS1b13fv3T6S0sS9vLRJTJ3fEEER3UJD64simKEpMTMyFOAxgZmv64l46QXQHBakvop5nmlkbE0HiVtMuN4smiO4Iq3tTlmRlMQ56e3MlOSXu76MrwiPvZWdnVqnUoFXzYY4O8vUSo2NfLF3d75svNp258MeDx+etrRzr1ApuH/wl+zpbzJvQnXvnx74N8/GuB4cQvSGVSkUS6t/Dbxt2cCCILqCF1Atx0RmEITaOehGkTCZbt2nsi/BbPTpNm/TVDgtzu5Xrh72LewVRErH8De+/Di72823zw5xL/XrOO395+92HpyAwNzfnty3jbawdp3yzq0Prr85d2paS8o7oDbGEig7PJIiOoCD1QuTTDEpvtzbs5Z0378L79pxXtXJDK8tyndp+Y25mc/HfncoEtWsE1q4ZJJFIK3rVLWfr9irqCQTef3Q2MSm2c7sJtjbOzo7e3TpOzshMIXpDJBWlJ8sIoiMoSL2QnkqLVL5ILl3CI+6KxdJK3v7sLkVRILzQ8NvKBO6u7xc2NTGxZIX3Li7SSGpiZ5vn9bWytLex1uNa0SKxWJZDEF3BPqR+oPT4inBGZqpMljN59meqgRbm75flotRZ5/SMZCNjM9UQqcSE6BGKQbeO7qAg9YKpuZgh+pKkpUU5IyPTYf2XqgaynyNqwczUKivrg6GIzCw9Dt/TuTIjveqdp6Ag9YJ7RVO96ZG4uVTOzs6wsXGyt8t7KS8uPkrVQqrF1sYlJyczOjbExckHdqOinyWn6PFFcFmOzMxBShAdwT6kXnAobwpt1uS3elnto1LFgKqVGv51YFFCYkxqWuLla3v+t27If7f+1n5UjWrNJBKjvw4shpGSpOS323bPMjPT43dSudm0kxeaSJ1BC6kvjIxF8ZEpVg4WRA8MG7Ds3+v7QFQRkfcd7CvUrd22acPe2g8xNbEYPmDZ4ROrZy0KBO8OjHzcundcT34n+ayQDGnSCQchdQY/UNYXRza/jnicUa2FJxEeEXej0+MyxyzxIYiOYJNVX7Qf4irLZrIzc4nwSHmb6e1rRhDdwSarHrG0E4ffiK7cpLymBHN/bJebm/1xOE3LYOiC0jCSOW38XgtzG1JKbNw6MezlXbVR4JiFwRK1UfOmHReL1Vee+KgkQpM2A/kwrV7Zg01WPSKTydZODqvZ2ktTgviEaKK7N9bOtjTrenLyu1xZttqorKwMY2P163OAz1bT8+Lh6TCPKqadRgpikoRSBy2kHhGLxW6VTJ+ci6jaooLaBMr3Zj4hVlb2pPR49eCNWERQjcUG+5D6pdtYN4mx3MlBhEFidNrIxV4EKS4oSL0zYr53enxm5KNYwnegsdq0WzmcubwkYB+yjPh12gsTW5MKvrydDPLBibB+0zzsnHCi5BKBgiw71k0NocSiKk0rEH4R9ehNwqu0ln3ta9QvNd+vYEFBlilbvw9LeiuzdjYr76vHT5/KjKTYlOgn8eAoHrnIE1uqpQIKsqx5/F/iud1xMpoxtTRy8LGxsjcnHCTy/puUt2kMTTyqmnUaiUOOpQYK8tNw62zc7bNJmWnyFZLFRkQsFYulEhgwyF+olYVSXbGVXTU5DwimmPfJ2AVelWnzkzGKpZCVWX2QWBki/05MpEj2vibAVVHsMq/5q8fSNC3LlTG5jCwXtojUiHKtZNxpuIDmgC4bUJCfmHuXEsMepCS+g5pOcnIY1a/sRSKQwfv1lFXLSf7xI0PY9cgVqx4rpPNeYvlHKZTJqKyMLN+g5MstfxDFrs5M8tZZZtMqlkln85GHSaSU1IgxMZe4VjT5rL2NkRE6b/QCChJBDAh8UwdBDAgUJIIYEChIBDEgUJAIYkCgIBHEgEBBIogB8X8AAAD//4XgaJwAAAAGSURBVAMABKmB2EU5aToAAAAASUVORK5CYII=",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "arch = Voyager(llm=llm)\n",
    "graph = arch.build()\n",
    "try:\n",
    "    display(Image(graph.get_graph().draw_mermaid_png()))\n",
    "except Exception as e:\n",
    "    print(f\"(PNG render unavailable: {e}; see § 2)\")\n",
    "    print(graph.get_graph().draw_mermaid())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118bfab7",
   "metadata": {
    "papermill": {
     "duration": 0.006074,
     "end_time": "2026-05-28T05:13:53.816522+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:53.810448+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 8 · Live run — 3 sequential tasks, library grows\n",
    "\n",
    "We deliberately pose two similar tasks (factorial of 5, factorial of 7) so Voyager reuses, then a new task (Fibonacci) that forces a new skill."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "361301c1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-28T05:13:53.825557Z",
     "iopub.status.busy": "2026-05-28T05:13:53.824556Z",
     "iopub.status.idle": "2026-05-28T05:14:11.098794Z",
     "shell.execute_reply": "2026-05-28T05:14:11.097214Z"
    },
    "papermill": {
     "duration": 17.282245,
     "end_time": "2026-05-28T05:14:11.100800+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:13:53.818555+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TASK_TAG: factorial_5\n",
      "  TASK: Compute the factorial of 5. Return just the integer.\n",
      "  DECISION: write_new\n",
      "  SKILL_NAME: factorial\n",
      "  INVOCATION: factorial(5)\n",
      "  LIBRARY_SIZE: 0 -> 1\n",
      "  EXECUTION_OK: True\n",
      "  EXECUTED_STDOUT: '120'\n",
      "  LLM_PREDICTED: ''\n",
      "  ANSWER: 120\n",
      "  EXPECTED: 120\n",
      "  MATCH: True\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TASK_TAG: factorial_7\n",
      "  TASK: Compute the factorial of 7. Return just the integer.\n",
      "  DECISION: reuse\n",
      "  SKILL_NAME: factorial\n",
      "  INVOCATION: factorial(7)\n",
      "  LIBRARY_SIZE: 1 -> 1\n",
      "  EXECUTION_OK: True\n",
      "  EXECUTED_STDOUT: '5040'\n",
      "  LLM_PREDICTED: '5040'\n",
      "  ANSWER: 5040\n",
      "  EXPECTED: 5040\n",
      "  MATCH: True\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TASK_TAG: fibonacci_8\n",
      "  TASK: Compute the 8th Fibonacci number (F(0)=0, F(1)=1). Return just the integer.\n",
      "  DECISION: write_new\n",
      "  SKILL_NAME: fibonacci\n",
      "  INVOCATION: fibonacci(8)\n",
      "  LIBRARY_SIZE: 1 -> 2\n",
      "  EXECUTION_OK: True\n",
      "  EXECUTED_STDOUT: '21'\n",
      "  LLM_PREDICTED: ''\n",
      "  ANSWER: 21\n",
      "  EXPECTED: 21\n",
      "  MATCH: True\n",
      "\n",
      "FINAL_LIBRARY_SIZE: 2\n",
      "  - skill `factorial`: Compute the factorial of a given number.\n",
      "  - skill `fibonacci`: Compute the nth Fibonacci number (F(0)=0, F(1)=1) and return the integer.\n"
     ]
    }
   ],
   "source": [
    "TASKS = [\n",
    "    (\"factorial_5\",  \"Compute the factorial of 5. Return just the integer.\"),\n",
    "    (\"factorial_7\",  \"Compute the factorial of 7. Return just the integer.\"),\n",
    "    (\"fibonacci_8\",  \"Compute the 8th Fibonacci number (F(0)=0, F(1)=1). Return just the integer.\"),\n",
    "]\n",
    "EXPECTED = {\"factorial_5\": \"120\", \"factorial_7\": \"5040\", \"fibonacci_8\": \"21\"}\n",
    "\n",
    "for tag, q in TASKS:\n",
    "    r = arch.run(q)\n",
    "    exp = EXPECTED[tag]\n",
    "    match = exp.strip().lower() in r.output.strip().lower()\n",
    "    print(f\"TASK_TAG: {tag}\")\n",
    "    print(f\"  TASK: {q}\")\n",
    "    print(f\"  DECISION: {r.metadata['decision']}\")\n",
    "    print(f\"  SKILL_NAME: {r.metadata['skill_used_name']}\")\n",
    "    print(f\"  INVOCATION: {r.metadata['invocation']}\")\n",
    "    print(f\"  LIBRARY_SIZE: {r.metadata['library_size_before']} -> {r.metadata['library_size_after']}\")\n",
    "    print(f\"  EXECUTION_OK: {r.metadata['execution_ok']}\")\n",
    "    print(f\"  EXECUTED_STDOUT: {r.metadata['executed_stdout']!r}\")\n",
    "    print(f\"  LLM_PREDICTED: {r.metadata['llm_predicted']!r}\")\n",
    "    print(f\"  ANSWER: {r.output[:100]}\")\n",
    "    print(f\"  EXPECTED: {exp}\")\n",
    "    print(f\"  MATCH: {match}\")\n",
    "    print()\n",
    "print(f\"FINAL_LIBRARY_SIZE: {len(arch.skills)}\")\n",
    "for s in arch.skills:\n",
    "    print(f\"  - skill `{s['name']}`: {s['description']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ca49d50",
   "metadata": {
    "papermill": {
     "duration": 0.004656,
     "end_time": "2026-05-28T05:14:11.110850+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:14:11.106194+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 9 · What we just observed\n",
    "\n",
    "The cells above ran Voyager on 3 sequential tasks — two factorials and a Fibonacci — to exercise both the **reuse** path and the **write-new** path.\n",
    "\n",
    "### 9.1 · Per-task summary\n",
    "\n",
    "| Tag | Decision | Skill used | Invocation | Library size | Exec OK | Executed stdout | LLM predicted | Match |\n",
    "|---|---|---|---|---|---|---|---|---|\n",
    "| `factorial_5` | `write_new` | `factorial` | `factorial(5)` | 0→1 | ✅ | `120` | `` | ✅ |\n",
    "| `factorial_7` | `reuse` | `factorial` | `factorial(7)` | 1→1 | ✅ | `5040` | `5040` | ✅ |\n",
    "| `fibonacci_8` | `write_new` | `fibonacci` | `fibonacci(8)` | 1→2 | ✅ | `21` | `` | ✅ |\n",
    "\n",
    "**Final library size**: 2\n",
    "\n",
    "### 9.2 · The skill library that built up\n",
    "\n",
    "- **`factorial`** — Compute the factorial of a given number.\n",
    "- **`fibonacci`** — Compute the nth Fibonacci number (F(0)=0, F(1)=1) and return the integer.\n",
    "\n",
    "### 9.3 · Patterns surfaced in this run\n",
    "\n",
    "- **✅ Skill reuse worked**: task 1 wrote `factorial`, task 2 retrieved + reused it.\n",
    "\n",
    "- **✅ Task 3 correctly wrote a new skill** (`fibonacci`) — different task type from prior 2.\n",
    "\n",
    "- **Real subprocess execution**: 3/3 skills ran successfully via `subprocess.run([sys.executable, '-I', '-c', script], timeout=5)`. The `Executed stdout` column shows the *actual* subprocess output, not an LLM prediction.\n",
    "\n",
    "- **Accuracy: 3/3** tasks answered correctly via the skill library.\n",
    "\n",
    "### 9.4 · The takeaway\n",
    "\n",
    "Voyager's value lives in two signals: the **`Decision`** column (how often does the agent reuse vs write?) and the **`Library size`** column (does it grow monotonically or plateau?). A healthy run:\n",
    "\n",
    "1. **First instance of a task type** → write_new, library grows.\n",
    "2. **Second instance of the same task type** → reuse, library stays.\n",
    "3. **New task type** → write_new, library grows again.\n",
    "\n",
    "When reuse fires correctly (§ 9.3), the architecture is amortising LLM cost across similar future tasks. The deterministic-picker is the LLM's `decision: Literal['reuse', 'write_new']` field plus a Python `if`-route — no numeric scoring."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8117747c",
   "metadata": {
    "papermill": {
     "duration": 0.005514,
     "end_time": "2026-05-28T05:14:11.121749+00:00",
     "exception": false,
     "start_time": "2026-05-28T05:14:11.116235+00:00",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 11 · Failure modes & extensions\n",
    "\n",
    "| Failure | Mitigation |\n",
    "|---|---|\n",
    "| **Bad skill reused** | Wrong skill retrieved; decider says reuse anyway | Strengthen decider prompt; require code-level check |\n",
    "| **Skill library bloat** | Many near-duplicate skills | Periodic dedup on description embeddings |\n",
    "| **Code doesn't actually work** | LLM-written skill has a bug | Sandbox exec + test before storing |\n",
    "\n",
    "Extensions: (1) sandboxed exec of skills (we predict results via LLM, not actually run code), (2) skill-versioning when a re-written skill supersedes an old one, (3) skill composition (call skill A from skill B).\n",
    "\n",
    "Reference: Wang et al., *Voyager*. 2023. [arXiv:2305.16291](https://arxiv.org/abs/2305.16291)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 24.807644,
   "end_time": "2026-05-28T05:14:12.111788+00:00",
   "environment_variables": {},
   "exception": null,
   "input_path": "all-agentic-architectures/notebooks/29_voyager.ipynb",
   "output_path": "all-agentic-architectures/notebooks/29_voyager.ipynb",
   "parameters": {},
   "start_time": "2026-05-28T05:13:47.304144+00:00",
   "version": "2.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}