@oneie/claude 0.9.0 → 0.10.0

package/skills/planning/SKILL.md

@@ -0,0 +1,256 @@
+---
+name: planning
+description: Turn a whole task board into a plan, and the plan into moved rows — tasks:board to see everything, tasks:bulk to act on it. Use whenever an agent has a goal and needs to know what already exists, what is ready, what is blocked and who owns it, or needs to file a plan tree, route unowned work, sweep a stale tag, or find the rows that became claimable when something closed. Triggers — "plan this", "what should I work on", "see the whole board", "what is ready", "what is blocked", "file the plan", "break this down into tasks", "route the unassigned work", "clean up these tasks", "how many tasks are there really".
+---
+
+# planning — the board is the plan
+
+**Purpose:** one loop. **See it all → decide → shape → act → close.** Every step is a
+receiver, none is a convention you can improvise, and the whole board is ONE request.
+
+**A page of tasks is not the board.** Measured 2026-09-13 and written into the contract
+(`packages/sdk/src/receivers.ts:2113-2118`): an agent asked for the board, hit a 200-row page,
+paged by six tags, found 353 more rows **by name only**, and never learned the real total.
+`tasks:board` exists so that cannot happen again — and so you can reason about 2,000 tasks
+while reading 0 of them.
+
+**Use the CLI first.** `one tasks board|bulk|set` (`packages/cli/src/tasks.ts`) is the fast door —
+it walks the pages, chunks writes at 25, and previews filter writes unless `--apply`. Pipe `--json`
+to a file and filter it with `node -e`/`jq`; never read 2,000 rows through the context window.
+
+    node packages/cli/dist/src/index.js tasks board --workspace one --tree --summary          # 1 — see it all
+    node packages/cli/dist/src/index.js tasks board --workspace one --tree --all --limit 2000 --include notes --json > board.json
+    node packages/cli/dist/src/index.js tasks set --workspace one --where-tag <t> --set-status dissolved --comment "why"   # preview
+    node packages/cli/dist/src/index.js tasks bulk --file plan.json --apply                   # file a whole plan tree
+    node packages/cli/dist/src/index.js tasks brief --workspace one --tree                     # one screen + next five moves
+    node packages/cli/dist/src/index.js tasks plan <goal-tid|tag> --workspace one --tree       # waves + critical path (hops)
+    node packages/cli/dist/src/index.js tasks plan <goal> --emit dispatch --out wave.json     # hand-off for factory-executor / tasks:launch
+    node packages/cli/dist/src/index.js tasks sequence <tid> <tid> <tid>                      # chain in order; preview unless --apply
+
+`brief`, `board` and `plan` default to `--kind work`: rows tagged `approval` are parked workflow
+runs, left out of the counts and COUNTED as excluded. Close one with `tasks_approve` /
+`workflow:stop`, never by status — `set --apply` refuses a match that holds one unless `--kind all`.
+`plan` reads a blocker's state from the server's `openBlockers`, never raw `blockedBy`: a closed
+blocker is satisfied, an open one outside the goal is `waits outside plan` and never dispatched.
+Dispatch hints ride in notes as labelled lines — `model:` `effort:` `touches:` `accept:` — and rows
+in one wave that share a `touches:` path are serialised. Promise + plan: `text/tasks-cli.md`.
+
+The raw HTTP door and the MCP tools below are the same receivers; use them only without a shell.
+If `tasks` is an unknown command the CLI `dist/` is stale — rebuild sdk then cli.
+
+Every door: `POST https://one.ie/api/ask/<receiver>`, `Authorization: Bearer $GATEWAY_API_KEY`
+(from `one.ie/web/.dev.vars`, **not `.env`**), body wrapped in `{"data":{…}}` or you get
+`envelope_missing`. Via MCP, `tasks_board` / `tasks_bulk` take the same fields.
+
+---
+
+## 1 — SEE IT ALL (always first, before any row read)
+
+```json
+{"data":{"workspace":"one","view":"summary","scope":"tree"}}
+```
+
+`view:"summary"` returns counts and sets and **no rows** — the cheapest way to see a 2,000-row
+board. `scope:"tree"` is this group **and every descendant** (the CEO / agency lens); default is
+`own`. Read the rows only once the summary told you which rows to ask for.
+
+**Four honesty fields. Read all four before you plan.**
+
+| Field | Means | Your next move |
+|---|---|---|
+| `total` | rows matching the filters **before paging**. Exact — *unless* `truncated.rows` is present, then it is a **floor** | quote it as the count, or as "at least N" |
+| `nextCursor` | present **iff** more rows match. Absent = you have them all | page until it is absent; never stop early and call it the board |
+| `truncated` | absent = nothing was cut. `.rows` = snapshot hit its budget · `.edges` = a row may read unblocked or orphaned when it is not · `.tags` = returned rows may be missing tags | **say so in your report** before planning on it |
+| `asOf` | ISO time the snapshot was built; rows are at most this stale | it is a KV memo, not a live read. `fresh:true` asks for a rebuild and is honoured **at most once per memo window** |
+
+**`summary` counts are over ALL matched rows; its id lists are a SAMPLE.**
+`summarizeBoard` counts every matched row (`one.ie/web/src/lib/tasks/board.ts:531`), but
+`readyIds` / `blockedIds` are the **top 50 by priority** (`board.ts:559-560`) and `byTag` is the
+**top 100 tags by count** (`board.ts:553`). A board with `ready: 300` hands you 50 ids — take the
+count from `summary`, take the rows from a filtered `view:"rows"` call with `nextCursor`.
+
+**Row width.** Compact rows already carry `tid,name,status,priority,tags,assignee,workspace,
+parent,blockedBy,openBlockers,ready,dueAt` — and `blockedBy`/`openBlockers` appear only when the
+row actually has blockers (`one.ie/web/src/lib/resolvers/task-board.ts:170`). Widen with
+`include: ["notes","graph","dates","thread"]`; `notes` is **clipped to 2000 chars per row**
+(`task-board.ts:182`) — read a whole goal one task at a time.
+
+---
+
+## 2 — DECIDE what to do
+
+Shipped in `summary` today (all computed in RAM over the matched set, no TypeDB):
+
+- **`ready`** — open **and** every blocker closed; a blocker not on the board counts as open, so
+  readiness is never reported on a guess (`board.ts:463-469`). The set a director can start now.
+- **`blocked`** — status `blocked`, or active with at least one open blocker.
+- **`unassigned`** · **`overdue`** — work with no owner, work past its date.
+- **`orphans`** — no parent, unreachable from any plan's containment walk.
+- **`noNotes`** — no prose goal: the rows a puller **cannot act on**. Not work, a title.
+
+**The unblockable row is the highest-value row on any board.** Status `blocked`, every blocker
+now closed — claimable in fact, invisible in practice, because `ready` requires
+`status === 'open'` (`board.ts:465`) and **nothing promotes it automatically**. Derive it today:
+ask `{"status":"blocked"}`, keep rows whose `openBlockers` is `0` or absent, then flip them with
+`tasks:bulk edits` (recipe D).
+
+**Designed, not built** — `summary.decisions` (`unrouted` · `unblocked` · `stalePicked` ·
+`deadlocked`) is **R10** of `text/tasks-inbox-plan.md` §6 and is not in the zod. So are
+`changedSince` (R9), `include:["route"]` + `summary.routes` (R11), and the CEO digest (R12).
+Zod **strips undeclared keys**, so sending one of those fields does not error — it silently
+degrades to a full cold read. Do not write payloads against them.
+
+---
+
+## 3 — SHAPE the work: chain before you fan out
+
+`tasks:claim` is **blocker-gated**, and the edges you write are what that gate reads. An
+unchained board hands every agent every row at once and nothing knows what comes first.
+
+**One call files a whole plan tree.** `tasks:bulk` `creates` (max 25) with `ref` handles:
+
+```json
+{"data":{"workspace":"one","creates":[
+  {"ref":"plan","title":"Launch the pricing page","notes":"Done when /pricing is live and converts"},
+  {"ref":"copy","title":"Write pricing copy","parent":"plan","notes":"Three tiers, no jargon"},
+  {"title":"Ship pricing page","parent":"plan","blockedBy":["copy"],"notes":"Deploy after copy lands"}]}}
+```
+
+**Ref rules — earlier-only.** A ref must be created **earlier in the same `creates` array** and
+its own create must have succeeded. A forward ref, a self ref, or a ref whose create failed is
+`unknown_ref`, and **nothing is written for that row** — a typo never reaches the substrate as a
+lookup (`one.ie/web/src/lib/resolvers/tasks.ts:2245-2252`). The receipt maps `ref → tid` in
+`created`.
+
+`tasks:subtask` does the same job **one row at a time** (row, notes, tags, containment edge and
+every `blockedBy` in one pipeline) and `tasks:depend` orders rows that already exist. **Never file
+a child with `tasks:create`** — it lands claimable, with no parent and no ordering.
+
+**The claim gate is wider than the board's `ready` flag.** `blockersResolved` requires every
+`blocks` blocker **AND every `containment` child** to be done|verified (`tasks.ts:614-619`,
+called by claim at `tasks.ts:963`), while the board's `isReady` reads `blockedBy` only
+(`board.ts:465-469`). So **a parent whose children are still open reads `ready:true` and
+`tasks:claim` refuses it `blocked`.** That is the design working — a plan root is unclaimable
+until its leaves close. Claim leaves, not roots.
+
+---
+
+## 4 — ACT
+
+**`where`+`set` is a DRY RUN by default.** `dryRun` is true unless you say `false` in so many
+words (`tasks.ts:2276-2278`). Read `matchedIds`, satisfy yourself they are the rows you meant,
+then resend the identical call with `"dryRun":false`.
+
+- The 25-row budget is **shared**: `where` pages at `MAX_BULK − (creates+edits)`
+  (`tasks.ts:2525`), and a `where`+`set` sent alongside a full 25 rows errors `too_many`
+  (`tasks.ts:2527`). Follow `nextCursor` to continue.
+- On a truncated snapshot the envelope adds a `detail` saying **`matched` is a floor, not a
+  total** (`tasks.ts:2577-2578`). Quote it that way.
+- **Put a `comment` on every change**, saying why — it lands in the task's inbox thread where the
+  humans already read. Side effect: **a comment heartbeats a `picked` lease**
+  (`tasks.ts:1943-1946`), so commenting on stale `picked` rows fights `tasks:reap`.
+- **`ok` is the CALL's outcome, never the rows'** (`tasks.ts:2687-2693`). Read
+  `applied` / `failed` / `notAttempted` — a row never attempted says so by name. And `created`
+  means **the row exists**, not that its later priority/dueAt/edge writes applied; that row's
+  receipt in `results` can still be `ok:false` (`tasks.ts:2682-2684`).
+- **Delegate in place** with `tasks:reassign` — never by filing a second task. Under a shared
+  gateway key a claim lands as the workspace, so follow `tasks:claim` with
+  `tasks:reassign {assignee:"<your slug>"}` or the ledger cannot say who took the row.
+- **`tasks:announce` returns `matched`, and matched is NOT delivered** — it is `actors.length`
+  from the fan-out (`one.ie/web/src/lib/resolvers/subscriptions.ts:1245` — the cite was
+  `:990`, which is a `lane = 'explore'` branch, not a `matched` line at all; `:928` is
+  `world:announce`'s). Quote it as reach.
+
+Claim · delegate · chat · chain as a *meeting* is the `meeting` skill and
+`.claude/agents/ceo.md § The four verbs`. Go there; don't restate it here.
+
+---
+
+## 5 — CLOSE THE LOOP
+
+The three locked rules, applied to a board turn:
+
+1. **Every signal closes** with `mark`, `warn` or `dissolve` — `tasks:bulk` marks on `applied`
+   and warns on `failed` (`tasks.ts:2679-2680`); your *report* closes too.
+2. **Structural time.** Tasks → waves → cycles. Never days, hours or weeks.
+3. **Deterministic numbers, from the RECEIPT.** `applied` / `failed` / `notAttempted` are
+   authoritative. **Do not re-read the board to verify your own write** — it is a KV memo stamped
+   `asOf` and `fresh:true` is rate-limited, so it can answer with rows that predate your edit.
+
+---
+
+## The five mistakes
+
+1. **Reading a page as the board** — six tag pages, 353 rows by name, no total. `view:"summary"` first, every time.
+2. **Quoting `matched` as delivered** — `tasks:announce` reports reach, not action.
+3. **Planning on a truncated board without saying so** — an unmentioned `truncated` turns a floor into a total.
+4. **A bulk `ok:true` that hid failed rows** — `ok` is the call; rows live in `applied`/`failed`/`notAttempted`.
+5. **Filing a child with `tasks:create`** — claimable, no parent, no ordering. Use `creates` or `tasks:subtask`.
+
+---
+
+## Recipes (valid against the zod)
+
+**A — Plan a feature.** One call, whole tree, ordering included.
+
+```json
+{"data":{"workspace":"one","creates":[
+ {"ref":"root","title":"Ship voice in chat","notes":"Done when a user can talk to a page and hear a reply","tags":["voice"],"priority":70},
+ {"ref":"api","title":"Wire the TTS receiver","parent":"root","notes":"Receiver + contract + test"},
+ {"title":"Voice bubble UI","parent":"root","blockedBy":["api"],"notes":"Push-to-talk and hands-free"}]}}
+```
+
+**B — Route unowned ready work.** Dry run, read `matchedIds`, then apply.
+
+```json
+{"data":{"workspace":"one","where":{"status":"open","ready":true,"assignee":"","tags":["launch"]},
+ "set":{"assignee":"cmo","comment":"Routing unowned ready launch work to marketing"},"dryRun":true}}
+```
+Then the same body with `"dryRun":false`. Follow `nextCursor` until absent; read `applied`.
+
+**C — Sweep a stale tag.** See it first, then dissolve with a reason.
+
+```json
+{"data":{"workspace":"one","tags":["q3-experiment"],"status":"active","view":"both","limit":100}}
+```
+```json
+{"data":{"workspace":"one","where":{"tags":["q3-experiment"],"status":"active"},
+ "set":{"status":"dissolved","comment":"Superseded by the Q4 plan — dissolved, not done"},"dryRun":false}}
+```
+A `picked` row in that sweep gets its lease heartbeat by the comment; reap it with `tasks:reap`
+rather than commenting it back to life.
+
+**D — Find what is unblockable.** The highest-value rows nobody knows are claimable.
+
+```json
+{"data":{"workspace":"one","scope":"tree","status":"blocked","limit":200}}
+```
+`openBlockers` is already on the compact row — no `include` needed. Keep rows whose
+`openBlockers` is `0` or absent, then promote them by name:
+```json
+{"data":{"workspace":"one","edits":[
+ {"tid":"task:<24hex>","status":"open","comment":"Every blocker closed — open and claimable"}]}}
+```
+
+**E — The CEO's turn, in its SHIPPED form.** Three calls.
+
+```json
+{"data":{"workspace":"one","scope":"tree","view":"summary"}}
+```
+```json
+{"data":{"workspace":"one","where":{"status":"open","ready":true,"assignee":"","scope":"tree"},
+ "set":{"assignee":"cto","comment":"Unowned and ready — routing to engineering"},"dryRun":true}}
+```
+…then the same call with `"dryRun":false`. **Designed, not built:** §6's faster turn
+(`changedSince` watermark, `include:["route"]`, `summary.routes` ranked by who staked the tags)
+is R9/R11/R12 of `text/tasks-inbox-plan.md` — until those ship, the CEO routes from its keyword
+table and its own judgment, and unstaked work stays the CEO's call.
+
+---
+
+## See also
+
+`packages/sdk/src/receivers.ts` — the contract; its `describe()` text is the spec, never invent a
+field · `.claude/skills/meeting/SKILL.md` — the room where rows move ·
+`.claude/agents/ceo.md § Seeing the whole board` · `text/tasks-inbox-plan.md` §5-§6 — the decided
+doctrine and the unbuilt rungs.

package/skills/typedb/SKILL.md

@@ -129,6 +129,13 @@ anything but `read`. `GET /v1/databases/one/schema` dumps the live schema —
 the fastest way to answer "is this fun actually deployed?". `GET /v1/version`
 returns the running build.
 
+**A timeout arrives as HTTP 500, not 408 or 503.** The body carries
+`"The operation was aborted due to timeout"` — and that string was absent from
+`RETRYABLE` in `one.ie/web/src/lib/substrate.ts` until 2026-09-14, so every timed-out
+read failed hard on the first try. Reads now retry it; **writes deliberately do
+not** — a write that timed out may already have committed, so retrying it is a
+duplicate, not a recovery. Classify by the message, never by the status code.
+
 The Python driver (`TypeDB.driver(...)`, `driver.transaction(...)`) is covered in
 the *Python Driver* section for reading upstream docs. **No code in this repo
 uses it** — there is no `typedb-driver` dependency in any `package.json` or

package/templates/template-agent.md

@@ -6,7 +6,7 @@
 name: {kebab-name}
 description: {One sentence — what this agent does and when to spawn it}
 tools: {comma-separated tool list}
-model: {haiku | sonnet | opus}
+model: {haiku | sonnet | opus}   # OPTIONAL — omit to inherit the default
 effort: {none | low | medium | high | xhigh}
 skills: {comma-separated skill list}
 subscribes: [{tag}, {tag}]  # the agent's stake — these tags route matching
@@ -39,6 +39,12 @@ You are the {name} agent. {One sentence role statement.}
 
 **Default:** pick the cheapest model that can answer. Stop at the first that decides.
 
+**`model:` is optional — omit it unless you are OVERRIDING.** It is `z.string().optional()` in the schema (`one.ie/web/src/lib/agent-schema.ts:236`), and an absent value resolves by the walk this whole estate resolves by — **agent → group → ancestor → platform** (`resolveModel`, `packages/sdk/src/billing.ts:179`) — ending at `DEFAULT_MODEL` = `x-ai/grok-4.5` (`billing.ts:138`), filled for `one.ie/ai/agents` by **channels** (`context.ts:592` → `personas.one`, `channels/src/personas.ts:61`) and for the separate `one.ie/web/ai/agents` tree by the web loaders (`agent-loader.ts:64`, `agents.ts:91`) — two trees, one `web/` apart, so check which glob covers your file before citing a loader. Declaring the default buys nothing and hides the walk, so write the line only when the answer differs from it.
+
+**The `kind: agent` genus has its own spec — `text/agents-spec.md`** — the field table across the six readers, the required set (`name` · `kind: agent` · a non-empty body), and the shapes the runtime cannot read; `oneie agent validate <path>` enforces it. This template is the other genus and is not validated by it.
+
+**Which spelling depends on which genus you are writing, and they are not interchangeable.** This template is the **Claude Code** shape (root-level `one.ie/ai/agents/<name>.md`, with `tools:`/`effort:`/scalar `skills:`) — it is spawned through the Agent tool, which accepts only the bare aliases `opus | sonnet | haiku | fable`, so those are what belongs above. A **`kind: agent`** file under `one.ie/ai/agents/<name>/agent.md` is the other genus and takes a full **OpenRouter id** instead — and OpenRouter versions ids with **dots**: `anthropic/claude-sonnet-4.5`, never `anthropic/claude-sonnet-4-5`. Nothing normalises between them (no `normalizeModel`/`MODEL_ALIAS` exists in web, sdk or channels), so a wrong-genus or hyphenated value fails silently at `gateway()` rather than at parse. Measured 2026-09-17: 78 of 105 `kind: agent` files carried an id `/api/openrouter-models` does not serve. Verify before you write one — `curl -s localhost:4321/api/openrouter-models | jq -r '.models[].id'`.
+
 ## The Three Locked Rules
 
 1. **Closed loop** — every output closes with a result, warn, or dissolve. No silent returns.

package/templates/template-feature.md

@@ -155,6 +155,15 @@ world:                     # the runtime the kept promise puts into the world
   workflow:  []            # "{kind}: …" — kinds (LOCKED): trigger·tool·skill·agent·condition·human·delay·sell
   agents:    []            # { name, subscribes: [tags] } — the tags are the stake (routing + inbox Space)
   skills:    []            # "{skill}: what it lets an agent do"
+  code:                    # the CODE the tag's family owns — every value a path relative to
+                           # the repo root, presence-checked EXACTLY like agents: a declared
+                           # path that does not exist → a cycle in the todo; present → skip.
+                           # Gate: `bash .claude/scripts/do-world-check.sh <slug>`.
+    ts:      []            # ["one.ie/web/src/lib/{slug}/tasks.ts"] — libs, resolvers, receivers
+    astro:   []            # ["one.ie/web/src/pages/{slug}.astro"]  — pages the tag ships
+    tql:     []            # ["schema/{slug}.tql"]                  — the tag asked as a query
+    panel:   []            # ["one.ie/web/src/components/{Slug}Panel.tsx"] — what a view mounts
+    command: []            # [".claude/commands/{slug}.md"]         — the operator's door
   tasks:
     tags: ["slug:{slug}"]  # the todo enters the world as a tagged weighted signal
   tracking:

package/templates/template-todo.md

@@ -16,6 +16,35 @@ tags: []                   # drives pheromone routing + W2 context triggers
 priority: 0                # 0 none · 1 should · 2 important · 3 critical — human override; do-rank.py reads it
 depends_on: []             # [other-slug, …] — plans that must be DONE before this is READY; powers do-rank.py's blocked/ready buckets + do-fleet conflict ordering
 
+# ─── BOARD CONTRACT (the plan and the board are ONE graph) ───────────
+# A plan's cycles and the board's rows are the same work in two renderings.
+# Until this block existed they were two graphs that drifted: `batches:` held
+# the ordering in markdown, D1 held it in `blocks` edges, and nothing joined
+# them — so a head reading the board could claim C5 while C1 was still open.
+#
+# THE JOIN IS NOT DECORATION. `tasks:claim` is BLOCKER-GATED and reads the very
+# `blocks` edge `tasks:depend` writes. So a plan whose batch DAG is mirrored onto
+# the board CANNOT be claimed out of order — the gate enforces the plan. A plan
+# that is not mirrored hands every agent every cycle at once, and the fan-out is
+# a race. Chain before you fan out.
+#
+# ONE GRAPH, TWO RENDERINGS:
+#   batches: [[C1],[C2,C3],[C4]]   ==   C2.blockedBy=[C1] · C3.blockedBy=[C1] · C4.blockedBy=[C2,C3]
+# If the two ever disagree, the BOARD is truth (the gate reads it) and the
+# batches list is stale — `do-plan-json.sh` emits both so the drift is visible.
+
+anchor: ""                 # task:<24hex> — the board row this plan answers to. The parent every
+                           # cycle row hangs off. Empty = the plan is not on the board and no
+                           # agent can find it: file the anchor FIRST, then write the plan.
+board_workspace: one       # where the rows live. Platform work lives in `one`; a client plan
+                           # lives in that client's slug.
+cycle_rows: []             # [{cycle: C1, tid: "task:…"}, …] — WRITTEN BY `do-board.sh <slug>`,
+                           # never by hand: it mints each row with tasks:subtask (parent = anchor,
+                           # blockedBy = the batch predecessors, tags slug:<slug>-c<n> + plan:<slug>)
+                           # and this list is the ONLY record of a cycle's tid — the cycle frames
+                           # below do not repeat it. `do-board.sh <slug> --status` reads it back.
+# ─────────────────────────────────────────────────────────────────────
+
 # ─── GOAL CONTRACT (the only thing that matters) ─────────────────────
 # PROMISE FAN-OUT: this file is spawned by the promise's derives.todo
 # at PLAN (text/<slug>.md is the promise). `outcome:` MUST be the

package/scripts/node_modules/@anthropic-ai/sdk/.github/logo.svg

@@ -1,3 +0,0 @@
-<svg width="248" height="248" viewBox="0 0 248 248" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M52.4285 162.873L98.7844 136.879L99.5485 134.602L98.7844 133.334H96.4921L88.7237 132.862L62.2346 132.153L39.3113 131.207L17.0249 130.026L11.4214 128.844L6.2 121.873L6.7094 118.447L11.4214 115.257L18.171 115.847L33.0711 116.911L55.485 118.447L71.6586 119.392L95.728 121.873H99.5485L100.058 120.337L98.7844 119.392L97.7656 118.447L74.5877 102.732L49.4995 86.1905L36.3823 76.62L29.3779 71.7757L25.8121 67.2858L24.2839 57.3608L30.6515 50.2716L39.3113 50.8623L41.4763 51.4531L50.2636 58.1879L68.9842 72.7209L93.4357 90.6804L97.0015 93.6343L98.4374 92.6652L98.6571 91.9801L97.0015 89.2625L83.757 65.2772L69.621 40.8192L63.2534 30.6579L61.5978 24.632C60.9565 22.1032 60.579 20.0111 60.579 17.4246L67.8381 7.49965L71.9133 6.19995L81.7193 7.49965L85.7946 11.0443L91.9074 24.9865L101.714 46.8451L116.996 76.62L121.453 85.4816L123.873 93.6343L124.764 96.1155H126.292V94.6976L127.566 77.9197L129.858 57.3608L132.15 30.8942L132.915 23.4505L136.608 14.4708L143.994 9.62643L149.725 12.344L154.437 19.0788L153.8 23.4505L150.998 41.6463L145.522 70.1215L141.957 89.2625H143.994L146.414 86.7813L156.093 74.0206L172.266 53.698L179.398 45.6635L187.803 36.802L193.152 32.5484H203.34L210.726 43.6549L207.415 55.1159L196.972 68.3492L188.312 79.5739L175.896 96.2095L168.191 109.585L168.882 110.689L170.738 110.53L198.755 104.504L213.91 101.787L231.994 98.7149L240.144 102.496L241.036 106.395L237.852 114.311L218.495 119.037L195.826 123.645L162.07 131.592L161.696 131.893L162.137 132.547L177.36 133.925L183.855 134.279H199.774L229.447 136.524L237.215 141.605L241.8 147.867L241.036 152.711L229.065 158.737L213.019 154.956L175.45 145.977L162.587 142.787H160.805V143.85L171.502 154.366L191.242 172.089L215.82 195.011L217.094 200.682L213.91 205.172L210.599 204.699L188.949 188.394L180.544 181.069L161.696 165.118H160.422V166.772L164.752 173.152L187.803 207.771L188.949 218.405L187.294 221.832L181.308 223.959L174.813 222.777L161.187 203.754L147.305 182.486L136.098 163.345L134.745 164.2L128.075 235.42L125.019 239.082L117.887 241.8L111.902 237.31L108.718 229.984L111.902 215.452L115.722 196.547L118.779 181.541L121.58 162.873L123.291 156.636L123.14 156.219L121.773 156.449L107.699 175.752L86.304 204.699L69.3663 222.777L65.291 224.431L58.2867 220.768L58.9235 214.27L62.8713 208.48L86.304 178.705L100.44 160.155L109.551 149.507L109.462 147.967L108.959 147.924L46.6977 188.512L35.6182 189.93L30.7788 185.44L31.4156 178.115L33.7079 175.752L52.4285 162.873Z" fill="#D97757"/>
-</svg>