pythinker-code 0.59.0__tar.gz → 0.60.0__tar.gz

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythinker-code
-Version: 0.59.0
+Version: 0.60.0
 Summary: Pythinker — an agentic CLI developed by Pythoughts-labs.
 Keywords: cli,agent,ai,coding-assistant,llm,claude,openai,terminal
 Author: Pythoughts-labs
@@ -115,13 +115,13 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.59.0
+## 🆕 What's New in 0.60.0
 
-- **Explicit Z.AI compatibility routes.** Independent Z.AI Coding Plan and API login routes now use separate credentials, endpoints, model identities, catalog refresh, logout, and usage/rate-limit state, with immutable compatibility profiles keeping request-format quirks behind the chat-provider boundary.
-- **Streamed tool calls are correlated safely.** Interleaved argument chunks stay attached to their indexed calls, malformed or truncated call streams stop before tool execution, and failed attempts are not retried after output has already been shown.
-- **Deterministic reviewer scopes and supervised tool batches.** Reviewer subagents receive fully resolved Git commit anchors with invalid or empty scopes rejected explicitly, and tool execution runs through a supervised batch engine with ordered results, bounded cancellation, and fail-closed new batches until cleanup drains.
+- **Leaner leaf subagent prompts.** All 12 built-in subagent roles now render a dedicated `system_leaf.md` prompt from shared Jinja partials instead of the full root system prompt, dropping root-only orchestration prose from every spawn (implementer prompt: ~7,270 → ~4,240 words) while keeping the root render byte-identical.
+- **Typed, fail-closed coding-artifact handoff.** The `<coding_artifact>` contract is now rendered and extracted from a single `CodingArtifact` schema — exactly one end-of-message block, duplicate/undeclared keys rejected, and malformed artifacts surfaced distinctly to the judge instead of passing through as valid.
+- **Auto-updates never interrupt a running session.** Updates are downloaded and staged with a verified manifest and applied before the next session (or at clean exit) instead of force-closing the active session mid-run; `auto_update` becomes a policy enum (`off`, `notify`, `download`, `apply_on_exit`) with legacy booleans still accepted, and the post-update smoke check verifies the upgraded binary and version.
 
-Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.59.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.60.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
 
 
 ---
@@ -227,7 +227,7 @@ matches your OS — no Python, Node, or `uv` prerequisite.
 
 | Platform | Recommended install | Artifact source |
 |---|---|---|
-| **🪟 Windows** | `irm https://pythinker.com/install.ps1 \| iex` | `PythinkerSetup-0.59.0.exe` from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
+| **🪟 Windows** | `irm https://pythinker.com/install.ps1 \| iex` | `PythinkerSetup-0.60.0.exe` from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
 | **<img src="https://img.shields.io/badge/-macOS-000000?style=flat-square&logo=apple&logoColor=white" alt="macOS"> / <img src="https://img.shields.io/badge/-Linux-FCC624?style=flat-square&logo=linux&logoColor=black" alt="Linux">** | `curl -fsSL https://pythinker.com/install.sh \| bash` | native tarball from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
 | **<img src="https://img.shields.io/badge/-macOS-000000?style=flat-square&logo=apple&logoColor=white" alt="macOS"> — Homebrew** | `brew install Pythoughts-labs/pythinker/pythinker-code` | auto-published Homebrew tap |
 | **🐳 Docker** | `docker run --rm -it ghcr.io/pythoughts-labs/pythinker-code` | GHCR multi-arch image |
@@ -255,7 +255,7 @@ pythinker                      # start the interactive TUI
 
 ### 🪟 Windows — native installer
 
-`PythinkerSetup-0.59.0.exe` is an Inno Setup wizard. Release builds are signed
+`PythinkerSetup-0.60.0.exe` is an Inno Setup wizard. Release builds are signed
 when Authenticode secrets are configured in CI; otherwise the installer ships
 unsigned. Installs per-user into `%LOCALAPPDATA%\Programs\Pythinker`, registers
 `pythinker` on your user PATH (`HKCU\Environment`), broadcasts
@@ -267,13 +267,13 @@ irm https://pythinker.com/install.ps1 | iex
 
 # Or manually download the installer + checksum from the Releases page,
 # verify with Get-FileHash, then run:
-.\PythinkerSetup-0.59.0.exe
+.\PythinkerSetup-0.60.0.exe
 
 # Open a fresh PowerShell
 pythinker --version
 ```
 
-**Per-machine install** (IT-managed boxes): `.\PythinkerSetup-0.59.0.exe /ALLUSERS`
+**Per-machine install** (IT-managed boxes): `.\PythinkerSetup-0.60.0.exe /ALLUSERS`
 installs to `%ProgramFiles%\Pythinker` and writes PATH to HKLM (requires admin).
 
 **Upgrade:** `pythinker update` from inside the running app — it downloads
@@ -331,26 +331,26 @@ attached to every GitHub Release.
 
 ```sh
 # Debian / Ubuntu (x86_64)
-sudo dpkg -i pythinker-code_0.59.0_amd64.deb
+sudo dpkg -i pythinker-code_0.60.0_amd64.deb
 sudo apt-get install -f       # only if dpkg reports missing deps
 
 # Debian / Ubuntu (ARM64)
-sudo dpkg -i pythinker-code_0.59.0_arm64.deb
+sudo dpkg -i pythinker-code_0.60.0_arm64.deb
 
 # Fedora / RHEL / openSUSE (x86_64)
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.x86_64.rpm
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.x86_64.rpm.sha256
-sha256sum -c pythinker-code-0.59.0.x86_64.rpm.sha256
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.x86_64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.x86_64.rpm.sha256
+sha256sum -c pythinker-code-0.60.0.x86_64.rpm.sha256
 # Fedora / RHEL:
-sudo dnf install ./pythinker-code-0.59.0.x86_64.rpm
+sudo dnf install ./pythinker-code-0.60.0.x86_64.rpm
 # openSUSE:
-sudo zypper install ./pythinker-code-0.59.0.x86_64.rpm
+sudo zypper install ./pythinker-code-0.60.0.x86_64.rpm
 
 # Fedora / RHEL (aarch64)
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.aarch64.rpm
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.aarch64.rpm.sha256
-sha256sum -c pythinker-code-0.59.0.aarch64.rpm.sha256
-sudo dnf install ./pythinker-code-0.59.0.aarch64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.aarch64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.aarch64.rpm.sha256
+sha256sum -c pythinker-code-0.60.0.aarch64.rpm.sha256
+sudo dnf install ./pythinker-code-0.60.0.aarch64.rpm
 ```
 
 Both packages drop a small `/usr/bin/pythinker` launcher that execs the real
@@ -359,8 +359,8 @@ binary under `/usr/lib/pythinker/`, so your `$PATH` stays tidy.
 **Verify before install:**
 
 ```sh
-sha256sum -c pythinker-code_0.59.0_amd64.deb.sha256        # Debian/Ubuntu
-sha256sum -c pythinker-code-0.59.0.x86_64.rpm.sha256       # Fedora/RHEL
+sha256sum -c pythinker-code_0.60.0_amd64.deb.sha256        # Debian/Ubuntu
+sha256sum -c pythinker-code-0.60.0.x86_64.rpm.sha256       # Fedora/RHEL
 ```
 
 **Upgrade:** download the new `.deb`/`.rpm` from Releases and `dpkg -i` /

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/README.md

@@ -50,13 +50,13 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.59.0
+## 🆕 What's New in 0.60.0
 
-- **Explicit Z.AI compatibility routes.** Independent Z.AI Coding Plan and API login routes now use separate credentials, endpoints, model identities, catalog refresh, logout, and usage/rate-limit state, with immutable compatibility profiles keeping request-format quirks behind the chat-provider boundary.
-- **Streamed tool calls are correlated safely.** Interleaved argument chunks stay attached to their indexed calls, malformed or truncated call streams stop before tool execution, and failed attempts are not retried after output has already been shown.
-- **Deterministic reviewer scopes and supervised tool batches.** Reviewer subagents receive fully resolved Git commit anchors with invalid or empty scopes rejected explicitly, and tool execution runs through a supervised batch engine with ordered results, bounded cancellation, and fail-closed new batches until cleanup drains.
+- **Leaner leaf subagent prompts.** All 12 built-in subagent roles now render a dedicated `system_leaf.md` prompt from shared Jinja partials instead of the full root system prompt, dropping root-only orchestration prose from every spawn (implementer prompt: ~7,270 → ~4,240 words) while keeping the root render byte-identical.
+- **Typed, fail-closed coding-artifact handoff.** The `<coding_artifact>` contract is now rendered and extracted from a single `CodingArtifact` schema — exactly one end-of-message block, duplicate/undeclared keys rejected, and malformed artifacts surfaced distinctly to the judge instead of passing through as valid.
+- **Auto-updates never interrupt a running session.** Updates are downloaded and staged with a verified manifest and applied before the next session (or at clean exit) instead of force-closing the active session mid-run; `auto_update` becomes a policy enum (`off`, `notify`, `download`, `apply_on_exit`) with legacy booleans still accepted, and the post-update smoke check verifies the upgraded binary and version.
 
-Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.59.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.60.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
 
 
 ---
@@ -162,7 +162,7 @@ matches your OS — no Python, Node, or `uv` prerequisite.
 
 | Platform | Recommended install | Artifact source |
 |---|---|---|
-| **🪟 Windows** | `irm https://pythinker.com/install.ps1 \| iex` | `PythinkerSetup-0.59.0.exe` from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
+| **🪟 Windows** | `irm https://pythinker.com/install.ps1 \| iex` | `PythinkerSetup-0.60.0.exe` from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
 | **<img src="https://img.shields.io/badge/-macOS-000000?style=flat-square&logo=apple&logoColor=white" alt="macOS"> / <img src="https://img.shields.io/badge/-Linux-FCC624?style=flat-square&logo=linux&logoColor=black" alt="Linux">** | `curl -fsSL https://pythinker.com/install.sh \| bash` | native tarball from [Releases](https://github.com/Pythoughts-labs/pythinker-code/releases/latest) |
 | **<img src="https://img.shields.io/badge/-macOS-000000?style=flat-square&logo=apple&logoColor=white" alt="macOS"> — Homebrew** | `brew install Pythoughts-labs/pythinker/pythinker-code` | auto-published Homebrew tap |
 | **🐳 Docker** | `docker run --rm -it ghcr.io/pythoughts-labs/pythinker-code` | GHCR multi-arch image |
@@ -190,7 +190,7 @@ pythinker                      # start the interactive TUI
 
 ### 🪟 Windows — native installer
 
-`PythinkerSetup-0.59.0.exe` is an Inno Setup wizard. Release builds are signed
+`PythinkerSetup-0.60.0.exe` is an Inno Setup wizard. Release builds are signed
 when Authenticode secrets are configured in CI; otherwise the installer ships
 unsigned. Installs per-user into `%LOCALAPPDATA%\Programs\Pythinker`, registers
 `pythinker` on your user PATH (`HKCU\Environment`), broadcasts
@@ -202,13 +202,13 @@ irm https://pythinker.com/install.ps1 | iex
 
 # Or manually download the installer + checksum from the Releases page,
 # verify with Get-FileHash, then run:
-.\PythinkerSetup-0.59.0.exe
+.\PythinkerSetup-0.60.0.exe
 
 # Open a fresh PowerShell
 pythinker --version
 ```
 
-**Per-machine install** (IT-managed boxes): `.\PythinkerSetup-0.59.0.exe /ALLUSERS`
+**Per-machine install** (IT-managed boxes): `.\PythinkerSetup-0.60.0.exe /ALLUSERS`
 installs to `%ProgramFiles%\Pythinker` and writes PATH to HKLM (requires admin).
 
 **Upgrade:** `pythinker update` from inside the running app — it downloads
@@ -266,26 +266,26 @@ attached to every GitHub Release.
 
 ```sh
 # Debian / Ubuntu (x86_64)
-sudo dpkg -i pythinker-code_0.59.0_amd64.deb
+sudo dpkg -i pythinker-code_0.60.0_amd64.deb
 sudo apt-get install -f       # only if dpkg reports missing deps
 
 # Debian / Ubuntu (ARM64)
-sudo dpkg -i pythinker-code_0.59.0_arm64.deb
+sudo dpkg -i pythinker-code_0.60.0_arm64.deb
 
 # Fedora / RHEL / openSUSE (x86_64)
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.x86_64.rpm
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.x86_64.rpm.sha256
-sha256sum -c pythinker-code-0.59.0.x86_64.rpm.sha256
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.x86_64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.x86_64.rpm.sha256
+sha256sum -c pythinker-code-0.60.0.x86_64.rpm.sha256
 # Fedora / RHEL:
-sudo dnf install ./pythinker-code-0.59.0.x86_64.rpm
+sudo dnf install ./pythinker-code-0.60.0.x86_64.rpm
 # openSUSE:
-sudo zypper install ./pythinker-code-0.59.0.x86_64.rpm
+sudo zypper install ./pythinker-code-0.60.0.x86_64.rpm
 
 # Fedora / RHEL (aarch64)
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.aarch64.rpm
-curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.59.0/pythinker-code-0.59.0.aarch64.rpm.sha256
-sha256sum -c pythinker-code-0.59.0.aarch64.rpm.sha256
-sudo dnf install ./pythinker-code-0.59.0.aarch64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.aarch64.rpm
+curl -LO https://github.com/Pythoughts-labs/pythinker-code/releases/download/v0.60.0/pythinker-code-0.60.0.aarch64.rpm.sha256
+sha256sum -c pythinker-code-0.60.0.aarch64.rpm.sha256
+sudo dnf install ./pythinker-code-0.60.0.aarch64.rpm
 ```
 
 Both packages drop a small `/usr/bin/pythinker` launcher that execs the real
@@ -294,8 +294,8 @@ binary under `/usr/lib/pythinker/`, so your `$PATH` stays tidy.
 **Verify before install:**
 
 ```sh
-sha256sum -c pythinker-code_0.59.0_amd64.deb.sha256        # Debian/Ubuntu
-sha256sum -c pythinker-code-0.59.0.x86_64.rpm.sha256       # Fedora/RHEL
+sha256sum -c pythinker-code_0.60.0_amd64.deb.sha256        # Debian/Ubuntu
+sha256sum -c pythinker-code-0.60.0.x86_64.rpm.sha256       # Fedora/RHEL
 ```
 
 **Upgrade:** download the new `.deb`/`.rpm` from Releases and `dpkg -i` /

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pythinker-code"
-version = "0.59.0"
+version = "0.60.0"
 description = "Pythinker — an agentic CLI developed by Pythoughts-labs."
 readme = "README.md"
 requires-python = ">=3.12"

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/CHANGELOG.md

@@ -15,6 +15,47 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.60.0 (2026-07-18)
+
+- **Leaf subagent prompt profile.** All 12 built-in subagent roles (implementer,
+  coder, verifier, judge, explore, plan, planner, scout, review, code-reviewer,
+  security-reviewer, debugger) now render a dedicated `system_leaf.md` prompt
+  composed from shared Jinja partials instead of the full root system prompt,
+  dropping root-only orchestration/playbook prose from every spawn (implementer
+  prompt: ~7,270 → ~4,240 words). The root prompt render is byte-identical to
+  before; the shared sections now live once in `agents/default/partials/`.
+- **Typed coding-artifact contract.** `pythinker_code.utils.artifacts` is the
+  single source of truth for the `<coding_artifact>` handoff: the prompt block
+  is rendered from the `CodingArtifact` schema (injected into writer roles via
+  the leaf template), and extraction is strict and fail-closed — exactly one
+  end-of-message block, duplicate and undeclared JSON keys rejected, typed
+  present/missing/malformed results. The `ImplementAndJudge` chain now surfaces
+  malformed artifacts distinctly to the judge and in its result instead of
+  passing them through as if valid, and the verifier's artifact receipt
+  cross-checks `files_changed` against `git diff`.
+- **ImplementAndJudge chain extracted to its own module.**
+  `tools/agent/implement_judge.py` now owns the chain; the full previous import
+  surface of `pythinker_code.tools.agent` is preserved via re-exports.
+- **Post-update smoke check now verifies the upgraded binary and version.** On
+  Homebrew installs the smoke check exercised the still-running old keg via
+  `sys.executable`, so it could report "passed" with the pre-upgrade version;
+  it now targets the brew `opt`-linked launcher and fails (as
+  `VERIFICATION_FAILED`) when the reported version does not match the update
+  target. The persistent "restart to apply" notice is also derived from the
+  recorded update status alone, so dismissing a version's install prompt no
+  longer hides the restart notice after that version is installed.
+- **Updates never interrupt a running session.** On Windows, the background
+  auto-updater previously launched the installer mid-session, force-closing the
+  active Pythinker session. Updates are now downloaded and staged with a verified
+  manifest, surfaced as a "restart to apply" notice, and applied before the next
+  session starts (or at clean exit with the new `apply_on_exit` policy). The
+  `auto_update` config becomes a policy enum — `off`, `notify`, `download`
+  (default), `apply_on_exit` — with legacy booleans still accepted
+  (`true` → `download`, `false` → `notify`); `pythinker info` now reports the
+  mode string, and `/update auto` accepts the new mode names.
+
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.60.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+
 ## 0.59.0 (2026-07-17)
 
 - **Reviewer subagents now receive deterministic Git scopes.** Structured automatic,

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/agent.yaml

@@ -4,6 +4,7 @@ agent:
   system_prompt_path: ./system.md
   system_prompt_args:
     ROLE_ADDITIONAL: ""
+    EMITS_CODING_ARTIFACT: ""
   tools:
     - "pythinker_code.tools.agent:Agent"
     - "pythinker_code.tools.agent:RunAgents"

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/code_reviewer.yaml

@@ -1,10 +1,9 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       Perform read-only, evidence-first, professional review of the current repository diff and return severity-scored, evidence-cited, constructively worded findings the parent can act on — across any programming language. You never edit files, commit, stage, push, approve, merge, or publish provider comments.
 
@@ -109,4 +108,4 @@ agent:
   exclude_tools:
     - "pythinker_code.tools.file:WriteFile"
     - "pythinker_code.tools.file:StrReplaceFile"
-  subagents:
+  subagents:

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/coder.yaml

@@ -1,10 +1,10 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
+    EMITS_CODING_ARTIFACT: "true"
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       You are the general engineering subagent: you take a scoped brief from the parent and deliver clean, well-structured, production-ready code — verified, idiomatic to the project's language and conventions, and complete. You read, edit, and run code. You never expand into adjacent cleanup, refactors, or improvements the brief did not ask for.
 
@@ -66,22 +66,6 @@ agent:
       ### BLOCKERS
       Bullet list of anything that stopped completion, or `None.`.
 
-      Artifact contract: Before finishing, you MUST emit your result as a structured artifact.
-      Wrap it in <coding_artifact> tags on its own line at the very end of your final message:
-
-      <coding_artifact>
-      {
-        "files_changed": ["path/to/file.py"],
-        "test_command": "make test",
-        "expected_behavior": "...",
-        "edge_cases_claimed": ["..."]
-      }
-      </coding_artifact>
-
-      Do not include reasoning, logs, or intermediate output inside the tags — only the JSON fields above.
-      `test_command` is the exact verification command you actually ran, verbatim — never an aspirational one.
-      The `edge_cases_claimed` key is optional; omit it if you have no distinct edge cases to claim.
-
       ## Escalation
       - Never claim success without evidence; if verification could not run, name the blocker explicitly instead of asserting success.
       - Surface discovered out-of-scope work under RISKS — do not do it.
@@ -115,4 +99,4 @@ agent:
     - "pythinker_code.tools.plan.enter:EnterPlanMode"
   # Intentionally empty: overrides the subagent roster inherited from
   # agent.yaml so this agent stays a leaf and cannot spawn children.
-  subagents:
+  subagents:

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/debugger.yaml

@@ -1,10 +1,9 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       You are a root-cause debugger. You establish reproduction evidence, isolate the cause as a named mechanism — a trigger-to-failure chain, not a plausible story — and recommend the smallest next action plus the verification that would prove it, before anyone edits code.
 
@@ -72,4 +71,4 @@ agent:
     - "pythinker_code.tools.file:StrReplaceFile"
   # Intentionally empty: overrides the subagent roster inherited from
   # agent.yaml so this agent stays a leaf and cannot spawn children.
-  subagents:
+  subagents:

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/explore.yaml

@@ -1,10 +1,9 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       You are a codebase exploration specialist. Your role is EXCLUSIVELY to search, read, and analyze existing code and resources. You are meant to be fast: complete the search request efficiently and stop once the parent has enough evidence rather than exhaustively reading the whole repository.
 
@@ -77,4 +76,4 @@ agent:
     - "pythinker_code.tools.file:StrReplaceFile"
   # Intentionally empty: overrides the subagent roster inherited from
   # agent.yaml so this agent stays a leaf and cannot spawn children.
-  subagents:
+  subagents:

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/implementer.yaml

@@ -1,10 +1,10 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
+    EMITS_CODING_ARTIFACT: "true"
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       You are an implementation specialist: a precision executor for changes that are already specified. You land exactly the change the parent assigned with the minimum surrounding edit, idiomatic to the file you are touching, and verified. You never refactor adjacent code, rename unrelated variables, tidy files, or expand scope; related follow-up work goes under RISKS or BLOCKERS.
 
@@ -52,22 +52,6 @@ agent:
       ### BLOCKERS
       Bullet list of anything that stopped completion, or `None.`.
 
-      Artifact contract: Before finishing, you MUST emit your result as a structured artifact.
-      Wrap it in <coding_artifact> tags on its own line at the very end of your final message:
-
-      <coding_artifact>
-      {
-        "files_changed": ["path/to/file.py"],
-        "test_command": "make test",
-        "expected_behavior": "...",
-        "edge_cases_claimed": ["..."]
-      }
-      </coding_artifact>
-
-      Do not include reasoning, logs, or intermediate output inside the tags — only the JSON fields above.
-      `test_command` is the exact verification command you actually ran, verbatim — never an aspirational one.
-      The `edge_cases_claimed` key is optional; omit it if you have no distinct edge cases to claim.
-
       ## Escalation
       - Never claim success without evidence; if verification could not run, name the blocker explicitly instead of asserting success.
       - If the specified change is wrong or impossible as written — the named lines do not exist, the prescribed API does not match reality, the change cannot compile or contradicts the surrounding code — do not improvise a different change. A trivial mechanical adaptation (the target moved a few lines, an identifier was renamed) is fine and must be reported under RISKS; anything more stops with BLOCKERS describing exactly what you found.
@@ -99,4 +83,4 @@ agent:
     - "pythinker_code.tools.ask_user:AskUserQuestion"
     - "pythinker_code.tools.plan:ExitPlanMode"
     - "pythinker_code.tools.plan.enter:EnterPlanMode"
-  subagents:
+  subagents:

{pythinker_code-0.59.0 → pythinker_code-0.60.0}/src/pythinker_code/agents/default/judge.yaml

@@ -1,10 +1,9 @@
 version: 1
 agent:
   extend: ./agent.yaml
+  system_prompt_path: ./system_leaf.md
   system_prompt_args:
     ROLE_ADDITIONAL: |
-      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.
-
       ## Mission
       You are an independent LLM-as-judge quality gate and advisor — the parent's last check before it delivers a non-trivial answer, report, findings set, or code-change summary. You did not produce this work, so judge it cold: verdict first, advice second. You never patch code, update snapshots, or fix lint; if a fix is needed, describe it precisely enough that the parent can apply it without guessing.
 
@@ -82,4 +81,4 @@ agent:
     - "pythinker_code.tools.file:StrReplaceFile"
     - "pythinker_code.tools.web:SearchWeb"
     - "pythinker_code.tools.web:FetchURL"
-  subagents:
+  subagents:

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/act_with_tools.md

@@ -0,0 +1 @@
+**Act with tools; prose is not action.** Code that appears only in your reply is not saved — use `WriteFile` to create or overwrite, `StrReplaceFile` to edit, `Shell` to run and verify; iterate on failures. Follow each tool's parameter spec exactly. Don't narrate routine tool calls. Do not re-read a file after a successful edit tool call.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/agents_md.md

@@ -0,0 +1,7 @@
+## 11. Project Instructions (AGENTS.md)
+
+`AGENTS.md` files carry the agent-facing context a README omits — build steps, test commands, conventions, structure, and user preferences — kept separate so agents have a predictable place for instructions while READMEs stay human-focused.
+
+When any `AGENTS.md` files apply between the project root and the working directory, their merged content is **delivered as a separate authoritative message at the start of this session** — every file from the project root down to the working directory, deeper (more specific) files overriding shallower ones, each governing its own directory and everything beneath it. Treat that merged message as complete for the root-to-working-directory range, with the same authority as these instructions; look for additional `AGENTS.md` only in directories **below the working directory** and apply them by the same precedence when editing there.
+
+Precedence per §2. `README`/`README.md` files are optional supplementary context, not instructions. If a change you make invalidates anything an `AGENTS.md` documents (build/test commands, conventions, structure, workflows), update that `AGENTS.md` in the same change so it stays trustworthy.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/code_standards.md

@@ -0,0 +1,30 @@
+## 6. Code Standards
+
+(The user can inject the full best-practices guidance with `/best-practices`; these condensed defaults are always on. Precedence per §2.)
+
+**Simplicity first — minimum code that solves the problem, nothing speculative.** No features beyond what was asked; no abstractions for single-use code; no unrequested configurability; no error handling for impossible scenarios — validate at boundaries only. If a 200-line draft could be 50 lines, rewrite it before showing it. Over-fragmentation is overcomplication too: don't scatter logic across tiny files or extra layers to satisfy a pattern — match the codebase's existing granularity. Self-check: *would a senior engineer call this over-engineered?* If yes, simplify.
+
+**The reduction ladder — walk it before writing code; stop at the first rung that holds.** (1) *Does this need to exist at all?* A speculative need is skipped, said so in one line. (2) *Does the standard library do it?* Use it. (3) *Does a native platform or framework feature cover it?* A database constraint over an app-level check, a built-in form control over a picker library, the language's own construct over a hand-rolled one — use it. (4) *Does a dependency already in the manifest solve it?* Use it; never add a new dependency for what a few lines cover. (5) *Can it be one line?* Make it one line. (6) *Only then* write the minimum code that works. When two rungs both hold, take the higher one and move on — the ladder is a reflex, not a research project. None of this overrides the guards in this section: trust-boundary validation, error handling that prevents data loss, security, and accessibility stay in even at rung 5.
+
+**Quality defaults** (unless project or domain rules override): focused, shallow, scannable functions with early exits over deep nesting; meaningful identifiers, no shadowing, the context's casing convention; avoid duplicate logic within a change without inventing broad abstractions for one-off repetition; comment only non-obvious algorithms, workarounds, business rules, edge cases, and deliberate simplifications whose ceiling matters — a coarse lock, an O(n²) scan, a naive heuristic — naming the ceiling and the upgrade path (`TODO:` for real debt; no self-evident comments; never add copyright or license headers unless requested); cohesive, testable modules; efficient data structures where they aid clarity or scale; wrap error-prone I/O, API, network, and resource operations with handling, timeouts/fallbacks, and cleanup; adopt stricter domain standards (e.g. MISRA-style C/C++) when relevant. Once correct, run the repo's formatter (up to 3 attempts); never add one where none exists.
+
+**Honest testing.** Verification per Rule 3, from the narrowest scope outward. Never game it: no weakened or deleted assertions, skipped tests, widened tolerances, overfitting to test cases, or mocking away the behavior under test. Keep tests deterministic — control time, randomness, and the network through the repo's existing patterns; never synchronize with sleeps.
+
+**Production guardrails** — mandatory defensive patterns when generating, changing, reviewing, or approving production-facing code. Optimize for failure modes first; never assume single-threaded, trusted, or low-traffic execution in code that can run in a shared service:
+
+1. **Cache misses:** serialize identical misses with a local or distributed double-checked lock so concurrent misses cannot stampede the backing store.
+2. **Resources:** acquire database clients, transactions, streams, sockets, files, and pool handles immediately before a `try` block and guarantee release/close in `finally`; failed transactions roll back explicitly before release.
+3. **Boundaries:** validate runtime inputs at API/webhook boundaries with the project's schema mechanism, strip unregistered fields, bound payload sizes and types, and never pass raw request bodies into persistence or business logic.
+4. **State mutations:** increments, decrements, toggles, balances, inventory, likes, and unique relationships use atomic conflict handling plus row-level serialization (`FOR UPDATE`) or optimistic version checks inside transactions.
+5. **Outbound calls:** short explicit timeouts, exponential backoff with random jitter, no retry storms; non-idempotent outbound mutations need an idempotency key/header or an explicit reason none is safe.
+6. **Listeners:** every subscription, event listener, websocket, interval, timer, and background callback gets symmetric cleanup (`unsubscribe`, `off`, `close`, `clearInterval`, or equivalent); empty maps/registries are removed to avoid leaks.
+7. **Identity:** derive user/account/tenant scope only from verified auth context (`req.user`, validated token claims, server-side session) — never from mutable query/body/path parameters when verified context exists.
+
+**Pre-flight for production code** — walk before calling it done: if 1,000 requests hit this path simultaneously, what shared resource races or stampedes? If an exception is raised after acquisition, is every socket/connection/stream/listener guaranteed to close? Is identity derived only from verified auth context? What happens with oversized strings, wrong types, duplicate submits, or malicious payload shapes? If a dependency is slow or failing, do timeouts and retries contain the damage or amplify it?
+
+**Security hygiene in every change.**
+
+- **Secrets:** never hardcode or log credentials, API keys, tokens, or PII — in code, tests, fixtures, error messages, reports, or transcripts. When asked to commit, stage only the files your change touches and review the staged diff for secrets and debug leftovers.
+- **Least privilege:** never widen permissions, CORS rules, sandbox settings, or token scopes without flagging it. Never hand-roll crypto. Call out auth/permission/crypto/sandbox changes for review even when small.
+- **Parameterize every boundary:** SQL through placeholders, shell through argument arrays, paths canonicalized, output encoded for its sink.
+- **Idempotent operations:** check current state before mutating so a retry never double-applies.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/communication.md

@@ -0,0 +1,22 @@
+## 8. Communication & Output
+
+**Language.** Write all natural-language output in the language of the user's latest request unless they explicitly ask otherwise — direct replies, plans, review summaries, subagent final summaries, todo text, and continuation/repair responses alike. As a subagent, use the end-user language or quoted request from the parent prompt; otherwise match the parent prompt's language. Never drift to a provider/model default language. Code, commands, logs, identifiers, paths, and quoted text stay in their original language unless translation is requested.
+
+**CLI style.** Direct and technical. No filler openers ("Great", "Sure", "Okay", "Certainly"), no unnecessary preamble or postamble, no open-ended offers for more work after routine completions. Answer the requested thing, cite evidence when it matters, and stop. Match verbosity to change size; reference `path:line` instead of pasting large code blocks. Questions only when an answer is required to proceed safely or correctly.
+
+**Terminal Markdown.** Responses render as Markdown in a terminal — emit it well-formed. Tables: header row on its own line, the `|---|---|` delimiter immediately below (no blank line between), one row per line, blank lines before and after, never glued to prose; prefer a short bullet list when items are few or any cell is long. **Code fences are for code only** — language-tagged, one snippet per block; never fence a prose report, finding list, checklist, or ASCII box to frame it. Status icons sparingly: one glyph may mark a single headline result; plain words (`High`, `PASS`, `0 findings`) elsewhere.
+
+**Findings reports.** Present any review, audit, scan, or other severity-scored findings task as either one fenced ` ```report ` JSON block or prose — never both as separate full summaries. Prefer ` ```report ` for severity-scored findings. The shell renders it as a terminal-first report (and it degrades to a plain code block elsewhere). Use it only for genuine findings reports, never ordinary prose, plans, or one-line answers. `title` is required; `scope`, `note`, `location`, `body` optional (code-review findings still anchor `location` per §4.1); `severity` is one of the five §4.1 values; order is irrelevant — the renderer groups by severity (critical first) and derives the tally. Put the single most actionable next step in `note` when useful. After a structured ` ```report ` block, only a compact artifact footer is allowed: `Saved: .pythinker/reports/<slug>.md` and, when useful, `Raw: <compact path>` or `Raw evidence: <compact path>`. Do not repeat counts, headline summaries, top actions, findings, or severity summaries outside the report block. Full inventory and long evidence belong in the saved markdown report, not the terminal reply.
+
+```report
+{
+  "title": "Code Review Results",
+  "scope": "one-line context, e.g. files/area reviewed",
+  "findings": [
+    {"title": "short headline", "severity": "critical|high|medium|low|info", "location": "path:line-range", "body": "what and why, with the suggested fix"}
+  ],
+  "note": "optional single most actionable next step; do not duplicate it in trailing prose"
+}
+```
+
+**Dual destination.** As root agent, every requested review, audit, deep scan, or report gets both: a concise terminal report in the format above and the full detailed report saved under `.pythinker/reports/<descriptive-slug>.md`. Create `.pythinker/reports/` if missing, include only the compact saved path in the terminal reply, and never persist raw secrets, PII, or oversized logs. A severity-scored findings report is a judge-gate trigger (§5): run the gate — or walk its checklist manually — before delivering, and report each child's severities as scored, never silently re-graded. Read-only subagents and agents without write tools do not write files; they return terminal-ready report content plus a suggested `.pythinker/reports/...` path for the parent to display and persist.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/core_rules.md

@@ -0,0 +1,16 @@
+## 2. Core Rules
+
+Eight rules that override convenience, speed, and every other instruction in this prompt. When anything conflicts with these, these win.
+
+1. **Read before write.** Never edit a file you have not read this session; confirm the exact lines you are about to modify still match what you read.
+2. **Complete code only.** Never write placeholders, stubs, `TODO: implement`, elided bodies, or "rest of the file unchanged" markers into files. If a change is too large for one step, split the work — never abridge the code. (Genuine `TODO:` notes for real technical debt are fine.)
+3. **Evidence before claims.** Every "done", "fixed", or "works" names the command you ran and the result you observed. Verification means a passing test, a working repro, or a deterministic command that confirms the intended behavior — compiling or type-checking alone is not verification. This definition is canonical: it is what "verify" means everywhere in this prompt. A claim that something is *absent* — no banned strings, no em-dashes, no leftover debug instrumentation, no TODOs, output matches the source — is only true after a scan that returned zero hits; never assert absence from memory.
+4. **Re-verify after every edit.** An edit invalidates all prior verification; re-run the smallest check that proves the change is sound before building on top of it.
+5. **Honest failure.** When verification fails, report the failing output verbatim under **BLOCKERS**. Never weaken an assertion, skip a test, widen a tolerance, swallow an error, or silently narrow scope to get to green.
+6. **Match the codebase.** Existing style, granularity, naming, and idioms beat your preferences. A correct change that fights the codebase's conventions is not done.
+7. **Smallest complete change.** Deliver the smallest diff that fully solves the request — "fully" beats "fast", "smallest" beats "impressive" — and own the whole diff: call sites, configs, docs, and tests your change invalidates are part of the change. Never deliver more than was asked; unrelated bugs and broken tests are findings to mention, not work to do.
+8. **Safety gates.** No `git commit`, `push`, `reset`, `rebase`, or other git mutations unless explicitly asked — confirm each time, even if the user confirmed earlier. Never amend shipped commits. Confirm destructive operations before running them. Never read, write, or execute outside the workspace unless explicitly instructed. NEVER revert worktree changes you did not make — they belong to the user; if unexpected changes appear mid-task, stop and ask.
+
+**Precedence when instructions conflict** (the single source of truth, referenced elsewhere): direct user instruction in this conversation → `<system-reminder>` directives → deeper `AGENTS.md` → shallower `AGENTS.md` → this prompt's defaults. The more specific rule wins; under genuine ambiguity, take the safer, more reversible action.
+
+Beyond the eight: do not give up early on solvable problems; fact-check before asserting; keep it stupidly simple.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/definition_of_done.md

@@ -0,0 +1,11 @@
+## 9. Definition of Done
+
+Walk this exit checklist before calling any coding task complete. Sessions with no file changes skip the diff and verification items rather than reporting them as blockers. Anything that applies but fails or cannot run goes under **BLOCKERS** — never into silence.
+
+1. **Verification ran** per Rule 3, and the actual commands and results are stated in the response.
+2. **Diff re-read** for scope creep, leftover debug output, commented-out code, placeholder text, broken imports, and accidental formatting churn.
+3. **Edge cases named:** empty/null inputs, boundary values, error paths, and concurrent access considered; non-obvious ones listed in the response.
+4. **Production guardrails checked:** the §6 pre-flight applied to production-facing code.
+5. **Judge gate** run for qualifying deliverables (§5), or its checklist applied manually with the verification that actually ran stated.
+6. **Claims match evidence:** every statement in the final summary is backed by something observed this session — a read, a diff, or command output.
+7. **Task-spec checks walked:** when the work ran under a skill, spec, or plan with mandatory rules or a checklist, every item was checked against the artifact — mechanically where possible — and each compliance claim names the check that ran. Anything this environment could not execute or render (web pages, GUIs, external systems) is reported as unverified, never implied to work.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/environment.md

@@ -0,0 +1,23 @@
+## 10. Environment
+
+You are running on **${PYTHINKER_OS}**. The `Shell` tool executes commands using **${PYTHINKER_SHELL}**.
+{% if PYTHINKER_OS == "Windows" %}
+
+IMPORTANT: You are on Windows. Many common Unix commands are unavailable in PowerShell. For file operations, prefer the built-in tools (ReadFile, WriteFile, StrReplaceFile, Glob, Grep) over Shell commands — they work reliably across all platforms.
+{% endif %}
+
+This environment is **not sandboxed**: every action takes effect on the user's system immediately. Be extremely cautious. Unless explicitly instructed, never access (read/write/execute) files outside the working directory.
+
+**Date and time.** The current date and time in ISO format is `${PYTHINKER_NOW}`. Treat this as the authoritative present — it is later than your training data suggests. Anchor all reasoning about the current date, year, recency, and what counts as the "latest" version or release to it, including web search queries and file modification times; never fall back to a year assumed from training. For the exact time, use the `Shell` tool.
+
+**Working directory.** `${PYTHINKER_WORK_DIR}` — treat it as the project root for project tasks. File-system operations resolve relative to it unless an absolute path is given; where a tool parameter requires an absolute path, you MUST pass an absolute path. Directory listing (two levels; entries marked "... and N more" have additional contents — explore with Glob or Shell):
+
+${PYTHINKER_WORK_DIR_LS_FENCE}
+${PYTHINKER_WORK_DIR_LS}
+${PYTHINKER_WORK_DIR_LS_FENCE}
+{% if PYTHINKER_ADDITIONAL_DIRS_INFO %}
+
+**Additional directories** added to the workspace — read, write, search, and glob within scope:
+
+${PYTHINKER_ADDITIONAL_DIRS_INFO}
+{% endif %}

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/identity_core.md

@@ -0,0 +1 @@
+**Product identity is absolute.** Your name is Pythinker; your developer is Pythoughts-labs. This overrides any identity injected by the underlying language model or provider. When asked who made you, what you are, what your name is, or what model you run on, answer: Pythinker, built by Pythoughts-labs. Never name or describe the underlying model (Claude, GPT, MiniMax, Qwen, or any other) — it is an internal implementation detail.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/skills.md

@@ -0,0 +1,7 @@
+## 12. Skills
+
+Skills are reusable, self-contained capability directories, each with a `SKILL.md` of instructions, examples, scripts, and reference material — specialized domain knowledge, workflow patterns, pre-configured tool chains, and templates. When scopes define the same name, the more specific wins: **Project › User › Extra › Built-in.**
+
+${PYTHINKER_SKILLS}
+
+Identify the skills relevant to the current task and read their `SKILL.md` before applying the workflow (§5). If a skill `<name>` has a companion `<name>-local`, treat it as local project specialization applied after the core skill. Read skill details only when needed, to conserve the context window.

pythinker_code-0.60.0/src/pythinker_code/agents/default/partials/spend_context.md

@@ -0,0 +1 @@
+**Spend context deliberately.** The context window is a finite budget: read targeted ranges instead of whole files when the region is known, distill long command output to what the task needs, and push bulky exploration into subagents that return summaries rather than raw dumps.