katvan 0.3.2__tar.gz → 0.3.3__tar.gz

{katvan-0.3.2 → katvan-0.3.3}/CHANGELOG.md

@@ -9,6 +9,17 @@ artifacts.
 
 ## [Unreleased]
 
+## [0.3.3] — 2026-05-24
+
+### Added
+
+- Three AgentCulture siblings to the culture.dev docs aggregation
+  (`site/_data/agentculture_repos.yml`), all `docs_mode: pull-reference`:
+  `lepenseur` and `lecodeur` (resident-culture, the mesh's local thinking
+  and coding agents) and `devague` (workspace-experience, the deterministic
+  idea→spec→plan CLI). Reference trees generated via `katvan pull`; nav index
+  pages added under `site/docs/<id>/`, mirroring `afi-cli` / `agtag`. Closes #36.
+
 ## [0.3.2] — 2026-05-24
 
 ### Added

{katvan-0.3.2 → katvan-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: katvan
-Version: 0.3.2
+Version: 0.3.3
 Summary: Maintain sibling-repo docs under one roof on the culture.dev site.
 Project-URL: Homepage, https://github.com/agentculture/katvan
 Project-URL: Issues, https://github.com/agentculture/katvan/issues

{katvan-0.3.2 → katvan-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "katvan"
-version = "0.3.2"
+version = "0.3.3"
 description = "Maintain sibling-repo docs under one roof on the culture.dev site."
 readme = "README.md"
 license = "MIT"

{katvan-0.3.2 → katvan-0.3.3}/site/_data/agentculture_repos.yml

@@ -120,6 +120,15 @@
   binary: code-lens
   related: [afi-cli]
 
+- id: devague
+  category: workspace-experience
+  maturity: usable
+  docs_mode: pull-reference
+  description: Turns a vague idea into a buildable spec, then that spec into a buildable plan — a deterministic CLI, not an agent.
+  binary: devague
+  install: uv tool install devague
+  related: [agex-cli, antoine]
+
 - id: zehut
   category: identity-secrets
   maturity: experimental
@@ -177,6 +186,24 @@
   docs_mode: skip
   description: Alignment hub for AgentCulture skills; maintains resident agents and registry hygiene.
 
+- id: lepenseur
+  category: resident-culture
+  maturity: experimental
+  docs_mode: pull-reference
+  description: The local thinking agent of the Culture mesh — reasons, plans, and analyzes; acts only via chat and files.
+  binary: lepenseur
+  install: uv tool install lepenseur
+  related: [lecodeur, steward]
+
+- id: lecodeur
+  category: resident-culture
+  maturity: experimental
+  docs_mode: pull-reference
+  description: The local coding agent of the Culture mesh — implements, edits, and tests code (the doer to lepenseur's thinker).
+  binary: lecodeur
+  install: uv tool install lecodeur
+  related: [lepenseur, steward]
+
 - id: appsec
   category: resident-domain
   maturity: experimental

katvan-0.3.3/site/docs/devague/index.md

@@ -0,0 +1,33 @@
+---
+title: devague
+parent: Workspace Experience
+nav_order: 6
+permalink: /devague/
+sites: [culture]
+---
+
+# devague
+
+**What it is.** A command-line tool that turns a vague feature idea into a
+buildable **spec**, then that spec into a buildable **plan** — by working
+backwards, then forwards. It is a small, deterministic Python CLI (no LLM calls
+inside it, fully unit-tested) — not an agent, service, or daemon.
+
+**Why you'd reach for it.** You have a fuzzy idea and want to pressure-test it
+into something you can actually build. The *frame* engine starts from the
+announcement ("pretend it shipped"), captures and interrogates claims, parks
+real unknowns, and exports a spec only once the frame *converges*. The *plan*
+engine then covers every target with tasks that carry acceptance criteria and
+an acyclic dependency order. Its anti-fabrication contract keeps LLM proposals
+"proposed" until a human confirms them.
+
+**Where it sits.** *Workspace Experience.* A dev-workflow tool for getting from
+idea to buildable plan, alongside the other CLIs agents reach for. Related:
+[agex-cli](/agex/), [antoine](/antoine/).
+
+**How to reach it.** Install with `uv tool install devague` and run it from the
+repository you are speccing; state is plain JSON under `.devague/`. Like every
+AFI binary it answers `devague learn` and `devague explain <move>` (both with
+`--json`).
+
+[Reference →](/docs/devague/reference/)

katvan-0.3.3/site/docs/devague/reference/index.md

@@ -0,0 +1,73 @@
+---
+title: devague reference
+parent: devague
+nav_order: 1
+sites: [culture]
+---
+
+# devague reference
+
+devague turns a vague idea into a buildable spec by working backwards.
+
+First question: What's the announcement?
+  Pretend this shipped successfully. What would you announce to users, teammates, or yourself?
+
+Start from that announcement, then build an Announcement Frame by capturing
+claims, interrogating them, parking what's still vague, and converging.
+The arc emerges from the moves; it is not a fixed wizard. You (the agent)
+choose the next move; devague tracks state. LLM-proposed claims and honesty
+conditions stay 'proposed' until the user confirms them.
+
+Guided stages (the recommended sequence — drive them with the moves):
+   1. Announcement  what are we saying shipped?  [new]
+   2. Audience      who needs this?  [capture --kind audience]
+   3. After         what changed for them?  [capture --kind after_state]
+   4. Matter        why is it worth doing?  [capture --kind why_it_matters]
+   5. Before        what pain made this necessary?  [capture --kind before_state]
+   6. Honest        what must be true for the announcement to be honest?  [interrogate --honesty]
+   7. FAQ           what hard questions remain?  [interrogate --hard-question]
+   8. Boundaries    what are we not promising?  [capture --kind boundary]
+   9. Success       how will we know?  [capture --kind success_signal]
+  10. Spec          what should be built?  [converge -> export]
+
+Moves:
+  new         Start a frame from the announcement (pretend it shipped).
+  capture     Record and classify a claim (audience, after_state, boundary, ...).
+  interrogate Pressure-test a claim: honesty conditions, hard questions, contradictions.
+  confirm     Confirm a claim or honesty condition (user-only — no fabricated rigor).
+  reject      Reject a claim or honesty condition.
+  park        Move uncertainty into first-class open vagueness instead of forcing an answer.
+  converge    Check whether the frame is solid enough to export a spec.
+  export      Write the buildable spec — only once the frame converges.
+  show        Render the Announcement Frame.
+  list        List frames.
+
+devague is NOT:
+  - a wizard (no fixed prompt sequence)
+  - a scripted questionnaire (you don't read questions off a form)
+  - a PRD generator (it never invents content to fill a template)
+
+Operating rules (the anti-fabrication contract — do not violate):
+  - LLM proposals stay proposed — capture your own ideas with --origin llm; never confirm your own proposal. Confirmation is a user-only decision.
+  - Honesty conditions route through the user — propose freely with 'interrogate --honesty'; the user owns whether each one holds.
+  - Park real unknowns instead of papering over them — 'park' a genuine unknown rather than writing confident prose that hides the gap.
+  - Converge, don't vibe — 'export' is gated on 'converge'; resolve every listed gap instead of declaring readiness on a hunch.
+  - Order is adaptive — the ten stages are an artifact shape, not a mandatory conversation order; capture what the user gives you and circle back.
+
+Assign-to-workforce: parallel plan execution via subagent-driven development
+  When: Once a plan converges (all targets covered, all tasks have acceptance criteria, dependency graph is acyclic), you can fan out its waves to parallel agents working in isolated git worktrees.
+  Prerequisites: A converged plan with deterministic dependency waves (devague plan waves).
+  Human gates (3): The human approves at exactly three points: (1) the exported spec, (2) the implementation split plan (plan/tasks map, per-task agent/model assignment, go/no-go to workforce), and (3) the final PR. The human is NOT in the per-task worktree-merge loop.
+  Safety: Each task runs in an isolated git worktree (one per task per wave). This keeps file-contention safe: overlapping same-file changes surface as merge conflicts at reconcile time, not live races.
+  Main agent: The main agent gates each subagent worktree merge with TDD: tests pass before AND after merge. No human per-task merge decision.
+  TDD: Each task carries TDD acceptance criteria (tests first) scoped tightly enough for a simpler/cheaper model to build. The tests validate that the task was built correctly — no re-deriving the design needed.
+  Scope: devague itself does not orchestrate: it does not spawn subagents, manage worktrees, mark tasks done, or pick a backend. Orchestration is a cited skill convention (assign-to-workforce), not part of the deterministic CLI.
+
+
+Full portable guidance for any assisting model:
+  https://github.com/agentculture/devague/blob/main/docs/llm-guidance.md
+  (in the devague repo: docs/llm-guidance.md)
+Agent-agnostic; your repo-specific agreements live in your agent's main
+instruction file — AGENTS.md, CLAUDE.md, a system prompt — not there.
+
+- [learn](learn.md)

katvan-0.3.3/site/docs/devague/reference/learn.md

@@ -0,0 +1,115 @@
+---
+title: devague learn
+parent: devague reference
+sites: [culture]
+---
+
+# `devague learn`
+
+```json
+{
+  "assign_to_workforce": {
+    "human_gates": "The human approves at exactly three points: (1) the exported spec, (2) the implementation split plan (plan/tasks map, per-task agent/model assignment, go/no-go to workforce), and (3) the final PR. The human is NOT in the per-task worktree-merge loop.",
+    "main_agent_merge_gate": "The main agent gates each subagent worktree merge with TDD: tests pass before AND after merge. No human per-task merge decision.",
+    "not_orchestration": "devague itself does not orchestrate: it does not spawn subagents, manage worktrees, mark tasks done, or pick a backend. Orchestration is a cited skill convention (assign-to-workforce), not part of the deterministic CLI.",
+    "prerequisites": "A converged plan with deterministic dependency waves (devague plan waves).",
+    "tdd_acceptance_criteria": "Each task carries TDD acceptance criteria (tests first) scoped tightly enough for a simpler/cheaper model to build. The tests validate that the task was built correctly \u2014 no re-deriving the design needed.",
+    "title": "Assign-to-workforce: parallel plan execution",
+    "when_to_fan_out": "Once a plan converges (all targets covered, all tasks have acceptance criteria, dependency graph is acyclic), you can fan out its waves to parallel agents working in isolated git worktrees.",
+    "worktree_isolation": "Each task runs in an isolated git worktree (one per task per wave). This keeps file-contention safe: overlapping same-file changes surface as merge conflicts at reconcile time, not live races."
+  },
+  "first_question": "What's the announcement?",
+  "guidance_doc": "https://github.com/agentculture/devague/blob/main/docs/llm-guidance.md",
+  "guidance_doc_repo_path": "docs/llm-guidance.md",
+  "moves": [
+    "new",
+    "capture",
+    "interrogate",
+    "confirm",
+    "reject",
+    "park",
+    "converge",
+    "export",
+    "show",
+    "list"
+  ],
+  "not_a": [
+    "a wizard (no fixed prompt sequence)",
+    "a scripted questionnaire (you don't read questions off a form)",
+    "a PRD generator (it never invents content to fill a template)"
+  ],
+  "operating_rules": [
+    "LLM proposals stay proposed \u2014 capture your own ideas with --origin llm; never confirm your own proposal. Confirmation is a user-only decision.",
+    "Honesty conditions route through the user \u2014 propose freely with 'interrogate --honesty'; the user owns whether each one holds.",
+    "Park real unknowns instead of papering over them \u2014 'park' a genuine unknown rather than writing confident prose that hides the gap.",
+    "Converge, don't vibe \u2014 'export' is gated on 'converge'; resolve every listed gap instead of declaring readiness on a hunch.",
+    "Order is adaptive \u2014 the ten stages are an artifact shape, not a mandatory conversation order; capture what the user gives you and circle back."
+  ],
+  "stages": [
+    {
+      "move": "new",
+      "name": "Announcement",
+      "prompt": "what are we saying shipped?",
+      "step": 1
+    },
+    {
+      "move": "capture --kind audience",
+      "name": "Audience",
+      "prompt": "who needs this?",
+      "step": 2
+    },
+    {
+      "move": "capture --kind after_state",
+      "name": "After",
+      "prompt": "what changed for them?",
+      "step": 3
+    },
+    {
+      "move": "capture --kind why_it_matters",
+      "name": "Matter",
+      "prompt": "why is it worth doing?",
+      "step": 4
+    },
+    {
+      "move": "capture --kind before_state",
+      "name": "Before",
+      "prompt": "what pain made this necessary?",
+      "step": 5
+    },
+    {
+      "move": "interrogate --honesty",
+      "name": "Honest",
+      "prompt": "what must be true for the announcement to be honest?",
+      "step": 6
+    },
+    {
+      "move": "interrogate --hard-question",
+      "name": "FAQ",
+      "prompt": "what hard questions remain?",
+      "step": 7
+    },
+    {
+      "move": "capture --kind boundary",
+      "name": "Boundaries",
+      "prompt": "what are we not promising?",
+      "step": 8
+    },
+    {
+      "move": "capture --kind success_signal",
+      "name": "Success",
+      "prompt": "how will we know?",
+      "step": 9
+    },
+    {
+      "move": "converge -> export",
+      "name": "Spec",
+      "prompt": "what should be built?",
+      "step": 10
+    }
+  ],
+  "summary": "devague turns a vague idea into a buildable spec by working backwards.\n\nFirst question: What's the announcement?\n  Pretend this shipped successfully. What would you announce to users, teammates, or yourself?\n\nStart from that announcement, then build an Announcement Frame by capturing\nclaims, interrogating them, parking what's still vague, and converging.\nThe arc emerges from the moves; it is not a fixed wizard. You (the agent)\nchoose the next move; devague tracks state. LLM-proposed claims and honesty\nconditions stay 'proposed' until the user confirms them.\n\nGuided stages (the recommended sequence \u2014 drive them with the moves):\n   1. Announcement  what are we saying shipped?  [new]\n   2. Audience      who needs this?  [capture --kind audience]\n   3. After         what changed for them?  [capture --kind after_state]\n   4. Matter        why is it worth doing?  [capture --kind why_it_matters]\n   5. Before        what pain made this necessary?  [capture --kind before_state]\n   6. Honest        what must be true for the announcement to be honest?  [interrogate --honesty]\n   7. FAQ           what hard questions remain?  [interrogate --hard-question]\n   8. Boundaries    what are we not promising?  [capture --kind boundary]\n   9. Success       how will we know?  [capture --kind success_signal]\n  10. Spec          what should be built?  [converge -> export]\n\nMoves:\n  new         Start a frame from the announcement (pretend it shipped).\n  capture     Record and classify a claim (audience, after_state, boundary, ...).\n  interrogate Pressure-test a claim: honesty conditions, hard questions, contradictions.\n  confirm     Confirm a claim or honesty condition (user-only \u2014 no fabricated rigor).\n  reject      Reject a claim or honesty condition.\n  park        Move uncertainty into first-class open vagueness instead of forcing an answer.\n  converge    Check whether the frame is solid enough to export a spec.\n  export      Write the buildable spec \u2014 only once the frame converges.\n  show        Render the Announcement Frame.\n  list        List frames.\n\ndevague is NOT:\n  - a wizard (no fixed prompt sequence)\n  - a scripted questionnaire (you don't read questions off a form)\n  - a PRD generator (it never invents content to fill a template)\n\nOperating rules (the anti-fabrication contract \u2014 do not violate):\n  - LLM proposals stay proposed \u2014 capture your own ideas with --origin llm; never confirm your own proposal. Confirmation is a user-only decision.\n  - Honesty conditions route through the user \u2014 propose freely with 'interrogate --honesty'; the user owns whether each one holds.\n  - Park real unknowns instead of papering over them \u2014 'park' a genuine unknown rather than writing confident prose that hides the gap.\n  - Converge, don't vibe \u2014 'export' is gated on 'converge'; resolve every listed gap instead of declaring readiness on a hunch.\n  - Order is adaptive \u2014 the ten stages are an artifact shape, not a mandatory conversation order; capture what the user gives you and circle back.\n\nAssign-to-workforce: parallel plan execution via subagent-driven development\n  When: Once a plan converges (all targets covered, all tasks have acceptance criteria, dependency graph is acyclic), you can fan out its waves to parallel agents working in isolated git worktrees.\n  Prerequisites: A converged plan with deterministic dependency waves (devague plan waves).\n  Human gates (3): The human approves at exactly three points: (1) the exported spec, (2) the implementation split plan (plan/tasks map, per-task agent/model assignment, go/no-go to workforce), and (3) the final PR. The human is NOT in the per-task worktree-merge loop.\n  Safety: Each task runs in an isolated git worktree (one per task per wave). This keeps file-contention safe: overlapping same-file changes surface as merge conflicts at reconcile time, not live races.\n  Main agent: The main agent gates each subagent worktree merge with TDD: tests pass before AND after merge. No human per-task merge decision.\n  TDD: Each task carries TDD acceptance criteria (tests first) scoped tightly enough for a simpler/cheaper model to build. The tests validate that the task was built correctly \u2014 no re-deriving the design needed.\n  Scope: devague itself does not orchestrate: it does not spawn subagents, manage worktrees, mark tasks done, or pick a backend. Orchestration is a cited skill convention (assign-to-workforce), not part of the deterministic CLI.\n\n\nFull portable guidance for any assisting model:\n  https://github.com/agentculture/devague/blob/main/docs/llm-guidance.md\n  (in the devague repo: docs/llm-guidance.md)\nAgent-agnostic; your repo-specific agreements live in your agent's main\ninstruction file \u2014 AGENTS.md, CLAUDE.md, a system prompt \u2014 not there.",
+  "supporting_prompt": "Pretend this shipped successfully. What would you announce to users, teammates, or yourself?",
+  "tool": "devague",
+  "version": "0.10.0"
+}
+```

katvan-0.3.3/site/docs/lecodeur/index.md

@@ -0,0 +1,28 @@
+---
+title: lecodeur
+parent: "Resident Agents"
+nav_order: 8
+permalink: /lecodeur/
+sites: [culture]
+---
+
+# lecodeur
+
+**What it is.** *"Le codeur" — the coder.* The local **coding** agent of the
+Culture mesh: a resident that implements, edits, and tests code. The "doer" to
+[lepenseur](/lepenseur/)'s "thinker".
+
+**Why you'd reach for it.** You want changes actually made — files written,
+edits applied, tests run — by a resident that stays on your own hardware rather
+than a hosted model. lecodeur is the half of the pair that turns a plan into a
+working diff.
+
+**Where it sits.** *Resident Agents.* The "coder" half of the thinker/coder
+pair — [lepenseur](/lepenseur/) reasons, lecodeur builds. Related:
+[lepenseur](/lepenseur/), [steward](/steward/).
+
+**How to reach it.** Install with `uv tool install lecodeur`; it lives on the
+mesh and is reached through Culture chat. Like every AFI binary it answers
+`lecodeur learn` and `lecodeur explain <topic>` (both with `--json`).
+
+[Reference →](/docs/lecodeur/reference/)

katvan-0.3.3/site/docs/lecodeur/reference/index.md

@@ -0,0 +1,12 @@
+---
+title: lecodeur reference
+parent: lecodeur
+nav_order: 1
+sites: [culture]
+---
+
+# lecodeur reference
+
+The local coding agent of the Culture mesh — implements, edits, and tests code (the doer to lepenseur's thinker).
+
+- [learn](learn.md)

katvan-0.3.3/site/docs/lecodeur/reference/learn.md

@@ -0,0 +1,46 @@
+---
+title: lecodeur learn
+parent: lecodeur reference
+sites: [culture]
+---
+
+# `lecodeur learn`
+
+```json
+{
+  "commands": [
+    {
+      "path": [
+        "whoami"
+      ],
+      "summary": "Identity probe (nick, version, backend, model)."
+    },
+    {
+      "path": [
+        "learn"
+      ],
+      "summary": "Self-teaching prompt."
+    },
+    {
+      "path": [
+        "explain"
+      ],
+      "summary": "Markdown docs by topic path."
+    }
+  ],
+  "exit_codes": {
+    "0": "success",
+    "1": "user-input error",
+    "2": "environment/setup error"
+  },
+  "explain_pointer": "lecodeur explain <path> (e.g. 'lecodeur explain backend')",
+  "json_support": true,
+  "purpose": "The local coding agent of the Culture mesh: implements, edits, and tests code. The 'doer' to lepenseur's 'thinker'.",
+  "siblings": {
+    "closest": "lepenseur",
+    "next": "daria"
+  },
+  "tool": "lecodeur",
+  "version": "0.1.0"
+}
+```

katvan-0.3.3/site/docs/lepenseur/index.md

@@ -0,0 +1,30 @@
+---
+title: lepenseur
+parent: "Resident Agents"
+nav_order: 7
+permalink: /lepenseur/
+sites: [culture]
+---
+
+# lepenseur
+
+**What it is.** *"Le penseur" — the thinker.* The local **thinking** agent of
+the Culture mesh: a long-lived resident that reasons, plans, and analyzes
+deeply. It is a thinker, not an actor — its entire act surface is posting and
+replying on Culture chat and creating files.
+
+**Why you'd reach for it.** You want a resident to think a problem through —
+weigh options, sketch a plan, pressure-test an idea — rather than edit code.
+lepenseur runs a locally-hosted vLLM reasoning model
+(`nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4`) over the `acp` backend, so
+the reasoning stays on your own hardware.
+
+**Where it sits.** *Resident Agents.* The "thinker" half of the thinker/coder
+pair — pair it with [lecodeur](/lecodeur/) when reasoning needs to become
+code. Related: [lecodeur](/lecodeur/), [steward](/steward/).
+
+**How to reach it.** Install with `uv tool install lepenseur`; it lives on the
+mesh and is reached through Culture chat. Like every AFI binary it answers
+`lepenseur learn` and `lepenseur explain <topic>` (both with `--json`).
+
+[Reference →](/docs/lepenseur/reference/)

katvan-0.3.3/site/docs/lepenseur/reference/index.md

@@ -0,0 +1,12 @@
+---
+title: lepenseur reference
+parent: lepenseur
+nav_order: 1
+sites: [culture]
+---
+
+# lepenseur reference
+
+The local thinking agent of the Culture mesh — reasons, plans, and analyzes; acts only via chat and files.
+
+- [learn](learn.md)

katvan-0.3.3/site/docs/lepenseur/reference/learn.md

@@ -0,0 +1,58 @@
+---
+title: lepenseur learn
+parent: lepenseur reference
+sites: [culture]
+---
+
+# `lepenseur learn`
+
+```json
+{
+  "commands": [
+    {
+      "path": [
+        "whoami"
+      ],
+      "summary": "Identity probe (nick, version, backend, model)."
+    },
+    {
+      "path": [
+        "learn"
+      ],
+      "summary": "Self-teaching prompt."
+    },
+    {
+      "path": [
+        "explain"
+      ],
+      "summary": "Markdown docs by topic path."
+    },
+    {
+      "path": [
+        "overview"
+      ],
+      "summary": "Descriptive snapshot of the agent."
+    },
+    {
+      "path": [
+        "doctor"
+      ],
+      "summary": "Self-diagnosis (stub)."
+    }
+  ],
+  "exit_codes": {
+    "0": "success",
+    "1": "user-input error",
+    "2": "environment/setup error"
+  },
+  "explain_pointer": "lepenseur explain <path> (e.g. 'lepenseur explain backend')",
+  "json_support": true,
+  "purpose": "The local thinking agent of the Culture mesh: reasons, plans, and analyzes deeply. The 'thinker' to lecodeur's 'coder'.",
+  "siblings": {
+    "closest": "lecodeur",
+    "next": "daria"
+  },
+  "tool": "lepenseur",
+  "version": "0.1.0"
+}
+```

{katvan-0.3.2 → katvan-0.3.3}/tests/cli/test_overview.py

@@ -26,16 +26,16 @@ def test_overview_text_lists_all_categories() -> None:
 def test_overview_text_counts_total_repos() -> None:
     result = _run()
     assert result.returncode == 0, result.stderr
-    assert "21 repos" in result.stdout
+    assert "24 repos" in result.stdout
 
 
 def test_overview_json_shape() -> None:
     result = _run("--json")
     assert result.returncode == 0, result.stderr
     payload = json.loads(result.stdout)
-    assert payload["total"] == 21
+    assert payload["total"] == 24
     assert set(payload["by_category"].keys()) == {
         "core-runtime", "workspace-experience", "identity-secrets",
         "resident-culture", "resident-domain", "org-site",
     }
-    assert sum(len(v) for v in payload["by_category"].values()) == 21
+    assert sum(len(v) for v in payload["by_category"].values()) == 24

{katvan-0.3.2 → katvan-0.3.3}/uv.lock

@@ -582,7 +582,7 @@ wheels = [
 
 [[package]]
 name = "katvan"
-version = "0.3.2"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "defusedxml" },