krita-cli 1.0.0__tar.gz → 1.0.1__tar.gz

krita_cli-1.0.1/.codex-plugin/agents/pelican-bike-illustrator.md

@@ -0,0 +1,70 @@
+---
+name: pelican-bike-illustrator
+description: |-
+  This skill should be used when the user asks to "draw a pelican on a bike", "turn pelican reference photos into a drawing", "fix a rough Krita sketch", or "build a reference-based animal illustration plan". Examples:
+
+  <example>
+  Context: The user wants a playful bird illustration and has provided pelican photos.
+  user: "Draw me a pelican on a bike."
+  assistant: "Use the pelican-bike-illustrator agent to collect references, extract the silhouette, and produce a concise Krita batch plan before painting."
+  </example>
+
+  <example>
+  Context: The user is unhappy with a rough first pass and wants a better result.
+  user: "That drawing is bad. Use pictures of pelicans and do it properly."
+  assistant: "Use the pelican-bike-illustrator agent to review references, identify the broken proportions, and rebuild the composition from larger shapes."
+  </example>
+
+  <example>
+  Context: The user is asking whether tracing or copying would help.
+  user: "Should we trace a pelican reference or copy the shape more directly?"
+  assistant: "Use the pelican-bike-illustrator agent to permit structural tracing from user-owned or open-licensed references, but not style copying."
+  </example>
+model: inherit
+color: magenta
+tools: ["Read", "Write", "Grep", "Bash"]
+---
+
+You are a reference-driven Krita illustration agent for animal-and-vehicle drawings.
+
+Your job is to turn pelican reference images into a new illustration that reads clearly at thumbnail size and remains original.
+
+**Core responsibilities**
+
+1. Inspect reference images for structure, proportion, silhouette, and pose.
+2. Separate subject anatomy from stylistic treatment.
+3. Decide when structural tracing is useful and when it is not.
+4. Build or revise Krita CLI batch commands that favor readability over detail.
+5. Export versioned outputs and compare them against the references.
+
+**Working rules**
+
+- Use user-provided, public-domain, or clearly licensed references when tracing.
+- Treat tracing as an anatomy and placement aid, not as a substitute for drawing.
+- Do not copy a living artist's style. Preserve only high-level energy such as bold shapes or playful proportions.
+- Prefer large shapes, strong contrast, and simple geometry when the image must be understood quickly.
+- If the bike is unclear, strengthen the wheel/frame separation before adding more detail.
+
+**Analysis process**
+
+1. Review the reference notes and identify the pelican's main masses.
+2. Identify what makes the image read as a bike: wheels, frame, saddle, and handlebar geometry.
+3. Draft a shape-first composition plan.
+4. If a drawing already exists, diagnose why it reads poorly: silhouette, overlap, proportion, contrast, or complexity.
+5. Produce the smallest useful batch of changes.
+6. Export a versioned image and compare the result against the references.
+
+**Output format**
+
+When asked to draw, return:
+
+- a short plan,
+- the key visual corrections,
+- the Krita CLI/batch commands or file edits required,
+- a brief note on what to check after export.
+
+**Edge cases**
+
+- If references are missing, ask for one or choose open-licensed images first.
+- If the source is a living artist's style request, convert it into a high-level mood description instead of copying the style.
+- If the first pass is unreadable, simplify the geometry and increase separation between body, wheels, and frame.

krita_cli-1.0.1/.codex-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "pelican-bike-drawing",
+  "interface": {
+    "displayName": "Pelican Bike Drawing"
+  },
+  "version": "0.1.0",
+  "description": "Reference-driven Krita drawing workflow for pelicans on bicycles."
+}

krita_cli-1.0.1/.codex-plugin/skills/pelican-bike-drawing/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: pelican-bike-drawing
+description: This skill should be used when the user asks to "draw a pelican on a bike", "sketch a bird on a bicycle", "use pelican reference photos", "trace a bird reference for Krita", or "improve a rough animal drawing with references".
+version: "0.8.8"
+---
+
+# Pelican Bike Drawing
+
+Use this skill to turn reference images into a clean Krita illustration of a pelican on a bicycle. Keep the result original, readable, and simple enough to work well in a CLI-driven drawing workflow.
+
+## Core Approach
+
+Start with references before drawing anything.
+
+1. Gather 2 to 4 references that show the subject clearly.
+2. Prefer user-provided images, public-domain images, or clearly licensed stock photos.
+3. Extract the subject structure before thinking about style.
+4. Build the drawing from broad shapes first, then add details.
+5. Export a versioned result and review it against the references.
+
+## What To Look For In Pelican References
+
+Identify the parts that matter most for a readable silhouette:
+
+- A large rounded body.
+- A high-set head with a small eye.
+- A long horizontal beak with a visible pouch.
+- A short neck and a smooth body transition.
+- Thin legs that can hang below the body.
+- Strong contrast between body mass and the narrow beak.
+
+When the subject is on a bike, keep the bicycle clearly separate from the bird:
+
+- Make both wheels obvious.
+- Leave enough space for the frame to read as a triangle or bar system.
+- Keep the pelican body perched above the frame, not merged into it.
+- Use thick, simple frame strokes instead of tiny mechanical detail.
+
+## When Tracing Is Worth Considering
+
+Use tracing only for structure and proportion.
+
+- Trace silhouettes, body masses, and the bike geometry when the goal is accurate placement.
+- Trace only from images that are user-owned, user-provided, or clearly open licensed.
+- Avoid copying copyrighted artwork or imitating a living artist's style.
+- Convert traced structure into a new drawing instead of reproducing the source image.
+
+Treat tracing as an anatomy shortcut, not as a final look.
+
+## Suggested Workflow
+
+1. Collect references and isolate the most useful one or two views.
+2. Note the main geometry: body oval, head circle, beak rectangle, wheel circles, frame bars.
+3. Draft the composition as simple shapes on a fresh canvas.
+4. Check the image at thumbnail size.
+5. If the bike is unclear, thicken the frame and simplify the body overlap.
+6. If the pelican is unclear, enlarge the beak, raise the head, and separate the neck from the torso.
+7. Export the canvas with a versioned filename.
+8. Compare the export against the references and decide what to fix next.
+
+## Krita CLI Findings
+
+These are workflow-specific lessons from the actual pelican-on-bike iteration history in this repo.
+
+- The `draw_shape` `line` primitive survives export more reliably than freehand `stroke` for bike frames.
+- If the bike must read instantly, spend the command budget on frame clarity before adding extra bird detail.
+- The plugin batch limit is 50 commands, so reserve duplicates only for the lines that matter most.
+- When a line needs to read thicker, duplicate it with a 1 to 2 pixel offset instead of assuming brush strokes will export cleanly.
+- Keep the pelican body high enough that the top tube, seat tube, and down tube are still visible underneath.
+- Treat the beak and pouch as separate shape systems: a yellow beak block plus orange pouch lines reads better than one generic orange stroke.
+- Test exports often. A composition that seems correct in the command plan can still fail visually in the PNG.
+- Once the frame is readable, the next quality gain comes from proportion: compact frame geometry and a believable seat/handlebar relationship look better than simply adding more lines.
+- The legs should terminate clearly on pedals; if they overshoot or bend too loosely, the rider pose becomes the weakest part of the image.
+- Small asymmetry helps. Even in a minimal drawing, offset pedal heights and slightly different leg paths make the rider read as posed instead of pinned in place.
+- After pose, the next improvement is contour hierarchy. A second neck or pouch contour can make the head-to-body transition feel more anatomical without forcing a more detailed style.
+- Keep that contour hierarchy simple. A pair of clean long contours reads better than several shorter neck segments once the composition is already working.
+- Head scale and beak length need restraint. Once the rider pose is working, slightly smaller head mass and a shorter beak can make the bird feel more unified instead of top-heavy.
+- When the proportions are already close, one strategic connector contour at the highest-value join can improve the drawing more than another full silhouette rewrite.
+- After the head/body join is working, controlled overlap becomes the next lever. Lowering the upper mass slightly can make the pelican feel seated on the bike instead of floating, but only if the top tube and frame triangle remain readable.
+- Once overlap is working, the next gains are often micro-adjustments. Small changes to head attitude and exact foot landing can improve the sense of intention more than any additional contour.
+- After micro-adjustments, look for calmness. A slightly lower upper mass and a quieter head position can make the drawing feel more settled without adding any new features.
+- After calmness is working, the next lever is character, not structure. Tiny changes to facial proportion or a single tail gesture can add personality without destabilizing the silhouette.
+- After character is working, proportion restraint becomes the next lever again. Small reductions in head or beak mass can make the bird feel cleaner and less blunt without changing the pose.
+- After restraint, look for elegance rather than reduction for its own sake. Slightly cleaner spacing around the face can make the bird feel more refined without making it smaller in every direction.
+- After elegance, look for poise. Tiny shifts in head position and face spacing can change the bird's demeanor without asking the composition to do anything structurally different.
+- After poise, look for coherence. Slightly tighter alignment between the head, eye, and beak can make the face feel more unified without changing the perch or bike.
+
+## Failure Review
+
+When a drawing looks bad, diagnose the failure before redrawing:
+
+- If it looks like a blob, the silhouette is too merged.
+- If it looks like a bird but not a pelican, the beak is too short or too generic.
+- If it looks like a pelican but not a bike, the wheels and frame are too weak.
+- If it looks stiff, the pose is too symmetrical.
+- If it looks overworked, remove detail and return to larger shapes.
+
+## Version-Specific Lessons
+
+- `version1` / `final`: the bird and bike read as disconnected objects and the bicycle structure is too weak.
+- `v3`: stronger body and wheel mass, but the bike frame is still buried under the pelican.
+- `v4`: frame geometry exists in the command plan, but the body overlap still prevents fast readability.
+- `v5`: better composition separation, but it still relies too much on primitives that do not survive export well enough.
+- `v6`: first structurally successful pass because the bike moved to explicit line shapes.
+- `v7`: improved `v6` by thickening the most important frame edges and preserving clearer separation between pelican, seat, and frame.
+- `v8`: refined the geometry rather than just the thickness, using a tighter frame and cleaner seat/handlebar placement for a more coherent bike.
+- `v9`: kept the compact `v8` geometry but improved the riding pose with more asymmetric leg placement.
+- `v10`: kept the `v9` pose and added a clearer neck/pouch contour so the pelican reads as a bird with anatomy rather than a body plus a separate head.
+- `v11`: simplified the neck/pouch treatment from `v10`, proving that cleaner long contours beat fussier segmented ones for this style.
+- `v12`: refined scale rather than structure, showing that a slightly smaller head and shorter beak can improve unity without changing the working composition.
+- `v13`: showed that once the body, head, and bike already work, a single deliberate connector contour can improve head-to-body integration better than another large redraw.
+- `v14`: showed that a slightly lower, more perched body placement can improve the rider read, provided the bike frame still stays visible underneath.
+- `v15`: showed that, after the perch is working, tiny refinements to head attitude and pedal contact can produce a cleaner, more intentional rider read without changing the overall composition.
+- `v16`: showed that tiny placement changes can also affect mood; a calmer head and slightly more settled body placement made the rider feel less twitchy while preserving the same simple structure.
+- `v17`: showed that, after calmness is established, very small face and tail adjustments can add character while keeping the same stable bike and body arrangement.
+- `v18`: showed that character can then be tightened through restraint; a slightly smaller head/beak relationship made the pelican feel cleaner without needing any new detail.
+- `v19`: showed that restraint can become elegance; slightly cleaner head and beak spacing made the bird feel more refined without changing the bike or perch.
+- `v20`: showed that elegance can then become poise; tiny head-placement changes made the pelican feel more self-possessed while preserving the same stable setup.
+- `v21`: showed that poise can be tightened into coherence; a slightly tighter head, eye, and beak relationship made the face feel more unified while preserving the same calm baseline.
+
+## Additional Resources
+
+### Reference Notes
+
+- `references/pelican-anatomy.md` - Pelican shape notes, reference checklist, and license-safe usage guidance.

krita_cli-1.0.1/.codex-plugin/skills/pelican-bike-drawing/references/pelican-anatomy.md

@@ -0,0 +1,32 @@
+# Pelican Anatomy Notes
+
+Use these notes as a quick structure checklist before drawing.
+
+## Visual Anchors
+
+- Pelicans read best as a body-first silhouette with a long beak.
+- The head usually sits high above the torso.
+- The body is broad and rounded, not narrow.
+- The bill pouch is a major visual cue; if it disappears, the bird becomes generic.
+- Legs are thin relative to the body and should not compete with the torso.
+
+## Composition Notes For A Bike Pose
+
+- Keep the wheels large enough to read instantly.
+- Keep the bike frame simple and geometric.
+- Let the bird occupy most of the upper mass.
+- Avoid tiny spokes and mechanical clutter unless the user explicitly wants detail.
+- Use overlap intentionally so the bird appears seated on the bike rather than floating above it.
+
+## Reference Usage
+
+- Prefer user-provided, public-domain, or clearly licensed photos.
+- Use reference images to understand proportion, pose, and silhouette.
+- Treat tracing as a structural aid only.
+- Redraw the result as a new illustration instead of copying the source photo.
+
+## Useful Reference Sources
+
+- Wikimedia Commons pelican photo: https://commons.wikimedia.org/wiki/File:Pelican.(Pelecanus_conspicillatus)_(14244840947).jpg
+- Unsplash side-profile pelican photo: https://unsplash.com/photos/a-pelican-with-a-small-fish-in-its-beak-FusF5pjKLmQ
+- Wikipedia pelican anatomy notes: https://en.wikipedia.org/wiki/Dalmatian_pelican

{krita_cli-1.0.0 → krita_cli-1.0.1}/.github/workflows/ci.yml

@@ -91,6 +91,8 @@ jobs:
           path: dist/
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
 
   publish-conda:
     name: Publish to Conda
@@ -107,7 +109,16 @@ jobs:
           channels: conda-forge,defaults
       - name: Build and Upload to Anaconda
         shell: bash -l {0}
+        env:
+          ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_API_TOKEN }}
         run: |
-          conda install -y anaconda-client conda-build
+          conda install -y conda-build
+          pip install anaconda-client
           conda build conda-recipe/ --output-folder dist/conda
-          anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload dist/conda/noarch/krita-cli-*.tar.bz2 --force
+          PKG_FILE=$(find dist/conda -name "krita-cli-*.tar.bz2" -o -name "krita-cli-*.conda" | head -n 1)
+          if [ -z "$PKG_FILE" ]; then
+            echo "No package file found!"
+            exit 1
+          fi
+          echo "Uploading $PKG_FILE"
+          anaconda upload "$PKG_FILE" --force

{krita_cli-1.0.0 → krita_cli-1.0.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: krita-cli
-Version: 1.0.0
+Version: 1.0.1
 Summary: SOTA CLI + MCP server for programmatic painting in Krita
-Project-URL: Homepage, https://github.com/github/krita-cli
-Project-URL: Repository, https://github.com/github/krita-cli
-Project-URL: Issues, https://github.com/github/krita-cli/issues
-Project-URL: Changelog, https://github.com/github/krita-cli/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/edithatogo/krita-cli
+Project-URL: Repository, https://github.com/edithatogo/krita-cli
+Project-URL: Issues, https://github.com/edithatogo/krita-cli/issues
+Project-URL: Changelog, https://github.com/edithatogo/krita-cli/blob/master/CHANGELOG.md
 Author: Krita MCP Contributors
 License-Expression: MIT
 License-File: LICENSE
@@ -39,7 +39,7 @@ This subproject provides the core implementation of the Krita-MCP ecosystem, inc
 
 ## 🛠️ Components
 
-1. **Krita Plugin** (`krita-plugin/`) — A Python plugin for Krita that exposes a thread-safe HTTP server on `localhost:5678`.
+1. **Krita Plugin** (`krita-plugin/`) — A Python plugin for Krita that exposes a thread-safe HTTP server on `localhost` using the configured port (default `5678`).
 2. **MCP Server** (`src/krita_mcp/`) — A FastMCP server exposing 40+ painting and manipulation tools.
 3. **Krita CLI** (`src/krita_cli/`) — A Typer-based command line interface for human operators.
 4. **Krita Client** (`src/krita_client/`) — A reusable, fully-typed Python library for Krita automation.
@@ -60,6 +60,22 @@ Enable **"Krita MCP Bridge"** in Krita (Configure Krita → Python Plugin Manage
 uv sync
 ```
 
+### 3. Windows Validation Checklist
+Before debugging the plugin, make sure the local Python runtime is healthy:
+
+1. `python -c "import ssl, ctypes"` must succeed.
+2. `python scripts/windows_preflight.py` should report a clean Windows setup.
+3. `uv run pytest tests/e2e/test_e2e_mock.py` should pass without Krita.
+4. The plugin files must exist under `%APPDATA%\krita\pykrita\kritamcp\`.
+5. Krita must be restarted after enabling **Krita MCP Bridge** in the Plugin Manager.
+6. The plugin should expose `http://127.0.0.1:<configured-port>/health` once Krita finishes loading.
+
+If Krita starts but `/health` never appears, check the diagnostic artifacts in your home directory:
+- `~/kritamcp_startup.log`
+- `~/kritamcp_diag.log`
+
+If those logs are missing entirely, the plugin likely was not enabled or did not load during startup.
+
 ## 🔧 CLI Commands
 
 The `krita` CLI is grouped into logical subcommands:

{krita_cli-1.0.0 → krita_cli-1.0.1}/README.md

@@ -6,7 +6,7 @@ This subproject provides the core implementation of the Krita-MCP ecosystem, inc
 
 ## 🛠️ Components
 
-1. **Krita Plugin** (`krita-plugin/`) — A Python plugin for Krita that exposes a thread-safe HTTP server on `localhost:5678`.
+1. **Krita Plugin** (`krita-plugin/`) — A Python plugin for Krita that exposes a thread-safe HTTP server on `localhost` using the configured port (default `5678`).
 2. **MCP Server** (`src/krita_mcp/`) — A FastMCP server exposing 40+ painting and manipulation tools.
 3. **Krita CLI** (`src/krita_cli/`) — A Typer-based command line interface for human operators.
 4. **Krita Client** (`src/krita_client/`) — A reusable, fully-typed Python library for Krita automation.
@@ -27,6 +27,22 @@ Enable **"Krita MCP Bridge"** in Krita (Configure Krita → Python Plugin Manage
 uv sync
 ```
 
+### 3. Windows Validation Checklist
+Before debugging the plugin, make sure the local Python runtime is healthy:
+
+1. `python -c "import ssl, ctypes"` must succeed.
+2. `python scripts/windows_preflight.py` should report a clean Windows setup.
+3. `uv run pytest tests/e2e/test_e2e_mock.py` should pass without Krita.
+4. The plugin files must exist under `%APPDATA%\krita\pykrita\kritamcp\`.
+5. Krita must be restarted after enabling **Krita MCP Bridge** in the Plugin Manager.
+6. The plugin should expose `http://127.0.0.1:<configured-port>/health` once Krita finishes loading.
+
+If Krita starts but `/health` never appears, check the diagnostic artifacts in your home directory:
+- `~/kritamcp_startup.log`
+- `~/kritamcp_diag.log`
+
+If those logs are missing entirely, the plugin likely was not enabled or did not load during startup.
+
 ## 🔧 CLI Commands
 
 The `krita` CLI is grouped into logical subcommands:

{krita_cli-1.0.0 → krita_cli-1.0.1}/conda-recipe/meta.yaml

@@ -1,5 +1,5 @@
 {% set name = 'krita-cli' %}
-{% set version = '1.0.0' %}
+{% set version = '1.0.1' %}
 
 package:
   name: {{ name|lower }}
@@ -9,6 +9,7 @@ source:
   path: ..
 
 build:
+  noarch: python
   number: 0
   script: {{ PYTHON }} -m pip install . --no-deps -vv
   entry_points:

{krita_cli-1.0.0 → krita_cli-1.0.1}/conductor/tracks/windows_testing_20260406/metadata.json

@@ -2,6 +2,7 @@
   "track_id": "windows_testing_20260406",
   "created_at": "2026-04-06",
   "status": "pending",
+  "updated_at": "2026-04-18T00:00:00Z",
   "phase": "12",
   "priority": "medium"
 }

krita_cli-1.0.1/conductor/tracks/windows_testing_20260406/plan.md

@@ -0,0 +1,35 @@
+# Implementation Plan: Windows Krita Validation & Plugin-Load Reliability
+
+## Phase 1: Runtime Preflight
+- Detect broken Windows Python runtimes before collection by importing native modules that fail in the current venv (`ssl`, `ctypes`).
+- Add a stdlib-only setup sanity check (`scripts/windows_preflight.py`) that explains how to repair the environment when the local interpreter is broken.
+- Keep the preflight separate from the main test suite so the failure mode is obvious.
+
+## Phase 2: CLI and MCP Validation
+- Verify the CLI imports and runs on a healthy Windows Python runtime.
+- Verify the MCP client/server packages import cleanly on the same runtime.
+- Keep the mock E2E suite as the default fallback for repo validation.
+
+## Phase 3: Plugin Deployment and Enablement Diagnostics
+- Verify the Krita plugin is copied into `%APPDATA%\krita\pykrita\` with both the `.desktop` file and the `kritamcp/` package.
+- Surface a clear message when Krita is running but `/health` never appears.
+- Distinguish between:
+  - plugin files missing or copied to the wrong location,
+  - plugin present but not enabled in Krita's Python Plugin Manager,
+  - plugin loaded but failing during import/startup,
+  - or a config/port mismatch.
+
+## Phase 4: Live Krita Smoke Validation
+- Keep a live Krita driver for Windows that launches Krita, opens a canvas, and waits for the HTTP health endpoint.
+- Exercise a minimal live smoke path: health, new canvas, one paint action, and one export or batch action.
+- Capture the existing startup log and diagnostic script outputs as the canonical troubleshooting path.
+
+## Phase 5: Documentation and Registry Updates
+- Update the Windows setup guide so the required workflow is explicit:
+  - healthy Python runtime,
+  - `uv sync`,
+  - copy plugin files,
+  - enable `Krita MCP Bridge`,
+  - restart Krita,
+  - verify `/health`.
+- Keep `krita-mcp/conductor/tracks.md` and the parent Conductor index pointed at this track so future debugging stays in one place.

krita_cli-1.0.1/conductor/tracks/windows_testing_20260406/spec.md

@@ -0,0 +1,31 @@
+# Track Specification: Windows Krita Validation & Plugin-Load Reliability
+
+## Problem Statement
+
+The Windows path for Krita MCP is not fully validated end to end. The project has a broken local Python runtime in the validation environment, the plugin files can be copied into `%APPDATA%\krita\pykrita`, and Krita can still fail to expose the HTTP server. That means the failure mode is ambiguous: the plugin may be missing, disabled in Krita's Plugin Manager, failing during import/startup, or simply bound to the wrong port.
+
+Without a dedicated Windows track, the repo cannot reliably distinguish:
+
+1. a broken Python/CLI/MCP environment,
+2. a correct install with the plugin disabled,
+3. a plugin startup/import failure,
+4. or a valid live Krita session where the health endpoint is reachable.
+
+## Requirements
+
+1. **Runtime Preflight** - Add a fast validation step that detects broken native Python dependencies before test collection. The known failure mode is `_ssl` / `_ctypes` import failure in the project venv.
+2. **CLI and MCP Validation** - Verify the CLI and MCP packages import and run on a healthy Windows Python runtime.
+3. **Plugin Deployment Check** - Verify the Krita plugin files are copied into `%APPDATA%\krita\pykrita\` with the expected `.desktop` file and package layout.
+4. **Enablement Diagnostics** - When Krita is running but `/health` is unavailable, report whether the likely issue is plugin disablement, import/startup failure, or a port/config mismatch.
+5. **Live Krita Smoke** - Keep a real Windows Krita smoke suite that exercises health, canvas creation, one paint action, and one export/batch path.
+6. **Mock E2E Coverage** - Keep the mock server E2E path as the default repo-level fallback so validation still runs without Krita.
+7. **Setup Docs** - Document the required Windows workflow: healthy Python runtime, `uv sync`, plugin copy target, Plugin Manager enablement, restart, and health verification.
+
+## Acceptance Criteria
+
+- [ ] A Windows preflight fails early when native Python imports are broken.
+- [ ] CLI and MCP tests run on a healthy Windows runtime.
+- [ ] The plugin install target and enablement step are documented clearly.
+- [ ] Live Krita failures distinguish disablement from startup/import failure.
+- [ ] Mock E2E continues to run without a real Krita session.
+- [ ] Windows setup guidance explains how to verify `/health` end to end.

{krita_cli-1.0.0 → krita_cli-1.0.1}/conductor/tracks.md

@@ -9,6 +9,13 @@ This file tracks all major tracks for the project. Each track has its own detail
 - [x] **Track: Selection Tools**
   *Link: [./tracks/selection_tools_20260406/](./tracks/selection_tools_20260406/)*
 
+- [ ] **Track: Windows Krita Validation & Plugin-Load Reliability**
+  *Link: [./tracks/windows_testing_20260406/](./tracks/windows_testing_20260406/)*
+  - Runtime preflight for broken Windows Python installs
+  - CLI and MCP validation on a healthy runtime
+  - Krita plugin deployment and enablement diagnostics
+  - Live Krita smoke validation and troubleshooting
+
 **Archived Tracks:**
 - [x] ~~Rollback Mechanisms~~ → [archive/rollback_mechanisms_20260405/](./archive/rollback_mechanisms_20260405/)
 - [x] ~~Command History & Replay~~ → [archive/command_history_replay_20260405/](./archive/command_history_replay_20260405/)

{krita_cli-1.0.0 → krita_cli-1.0.1}/krita-plugin/kritamcp/__init__.py

@@ -23,18 +23,46 @@ import os
 import sys
 import threading
 import uuid
-from http.server import BaseHTTPRequestHandler, HTTPServer
+from http.server import BaseHTTPRequestHandler, HTTPServer, ThreadingHTTPServer
 from typing import Any
+from urllib.parse import urlparse
+
+try:
+    with open(os.path.expanduser("~/kritamcp_startup.log"), "a") as _f:
+        import datetime as _dt
+        _f.write(f"[{_dt.datetime.now().isoformat()}] kritamcp import begin as {__name__} (Python {sys.version})\n")
+except Exception:
+    pass
 
 from krita import *
-from PyQt5.QtCore import QThread, QTimer, QPolygon, QPoint
-from PyQt5.QtGui import QColor
+from PyQt5.QtCore import QThread, QTimer, QPoint
+from PyQt5.QtGui import QColor, QPolygon
 
 from kritamcp.history_store import CommandHistoryStore
 from kritamcp.payload_validator import validate_payload_size, MAX_PAYLOAD_SIZE
 from kritamcp.rate_limiter import RateLimiter
 from kritamcp.snapshot_store import BatchSnapshotStore
 
+# -- Startup diagnostics (file log so failures are visible outside Krita) ----
+_DIAG_LOG = os.path.expanduser("~/kritamcp_startup.log")
+def _log_diag(message: str) -> None:
+    try:
+        with open(_DIAG_LOG, "a") as _f:
+            import datetime as _dt
+            _f.write(f"[{_dt.datetime.now().isoformat()}] {message}\n")
+    except Exception:
+        pass
+
+
+def _expand_user_path(path: str) -> str:
+    """Expand user and environment markers in a filesystem path."""
+    return os.path.expandvars(os.path.expanduser(path))
+
+try:
+    _log_diag(f"kritamcp module loaded as {__name__} (Python {sys.version})")
+except Exception:
+    pass
+
 # Try to import numpy for accelerated rendering
 try:
     import numpy as np
@@ -284,11 +312,14 @@ class ServerThread(QThread):
 
     def run(self) -> None:
         try:
-            self.server = HTTPServer(("localhost", self.port), PaintRequestHandler)
+            _log_diag(f"HTTP server thread starting on port {self.port}")
+            self.server = ThreadingHTTPServer(("localhost", self.port), PaintRequestHandler)
             logger.info("HTTP server started on port %d", self.port)
+            _log_diag(f"HTTP server started on port {self.port}")
             self.server.serve_forever()
         except OSError as exc:
             logger.error("Failed to start HTTP server on port %d: %s", self.port, exc)
+            _log_diag(f"HTTP server failed on port {self.port}: {exc}")
 
     def stop(self) -> None:
         if self.server:
@@ -303,6 +334,7 @@ class KritaMCPExtension(Extension):
     """Main Krita extension class."""
 
     def __init__(self, parent: Any) -> None:
+        _log_diag("KritaMCPExtension.__init__ begin")
         super().__init__(parent)
         self.server_thread: ServerThread | None = None
         self.timer: QTimer | None = None
@@ -316,6 +348,9 @@ class KritaMCPExtension(Extension):
         # Load configuration
         self.config_path = os.path.expanduser("~/.kritamcp_config.json")
         self.load_config()
+        _log_diag("KritaMCPExtension.__init__ after load_config")
+        self._ensure_runtime_started()
+        _log_diag("KritaMCPExtension.__init__ end")
 
     def _detect_capabilities(self) -> dict[str, bool]:
         """Detect which selection APIs are available in this Krita version."""
@@ -348,9 +383,10 @@ class KritaMCPExtension(Extension):
         # Add Krita API version info
         try:
             from krita import Krita
-            krita_version_str = Krita.version()
+            krita_instance = Krita.instance()
+            krita_version_str = krita_instance.version() if krita_instance else Krita.version()
             capabilities["krita_version"] = krita_version_str
-        except (AttributeError, ImportError):
+        except (AttributeError, ImportError, TypeError):
             capabilities["krita_version"] = "unknown"
         
         return capabilities
@@ -386,9 +422,7 @@ class KritaMCPExtension(Extension):
                 with open(krita_cli_config, encoding="utf-8") as f:
                     config = json.load(f)
                     SERVER_PORT = config.get("port", SERVER_PORT)
-                    CANVAS_OUTPUT_DIR = config.get(
-                        "canvas_output_dir", os.path.expanduser(config.get("canvas_output_dir", CANVAS_OUTPUT_DIR))
-                    )
+                    CANVAS_OUTPUT_DIR = _expand_user_path(config.get("canvas_output_dir", CANVAS_OUTPUT_DIR))
                     MAX_CANVAS_DIM = config.get("max_canvas_dim", MAX_CANVAS_DIM)
                     MAX_BATCH_SIZE = config.get("max_batch_size", MAX_BATCH_SIZE)
                     MAX_LAYERS = config.get("max_layers", MAX_LAYERS)
@@ -403,22 +437,29 @@ class KritaMCPExtension(Extension):
                 with open(self.config_path, encoding="utf-8") as f:
                     config = json.load(f)
                     SERVER_PORT = config.get("port", SERVER_PORT)
-                    CANVAS_OUTPUT_DIR = config.get(
-                        "output_dir", os.path.expanduser(config.get("output_dir", CANVAS_OUTPUT_DIR))
-                    )
+                    CANVAS_OUTPUT_DIR = _expand_user_path(config.get("output_dir", CANVAS_OUTPUT_DIR))
                     MAX_CANVAS_DIM = config.get("max_canvas_dim", MAX_CANVAS_DIM)
                     logger.info("Loaded config from %s", self.config_path)
             except Exception as e:
                 logger.error("Failed to load config from %s: %s", self.config_path, e)
 
     def setup(self) -> None:
-        pass
+        self._ensure_runtime_started()
 
     def createActions(self, window: Any) -> None:
         """Called when a new window is created."""
+        self._ensure_runtime_started()
+
+    def call(self, action: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Backward-compatible generic dispatcher used by the live tests."""
+        return self.handle_command(action, params or {})
+
+    def _ensure_runtime_started(self) -> None:
+        """Start background runtime pieces once, regardless of Krita's callback order."""
         os.makedirs(CANVAS_OUTPUT_DIR, exist_ok=True)
 
         if self.server_thread is None:
+            _log_diag(f"Requested HTTP server startup on port {SERVER_PORT}")
             self.server_thread = ServerThread(SERVER_PORT)
             self.server_thread.start()
 
@@ -2161,9 +2202,14 @@ class KritaMCPExtension(Extension):
 
 
 # Register the extension
-if __name__ != "builtins" and "pytest" not in sys.modules:
+if "pytest" not in sys.modules:
     try:
         Krita.instance().addExtension(KritaMCPExtension(Krita.instance()))
-    except (NameError, AttributeError):
+        _log_diag("Krita.instance().addExtension completed")
+    except (NameError, AttributeError) as exc:
         # Krita not defined or instance() not available
+        _log_diag(f"Extension registration unavailable: {exc}")
+        pass
+    except Exception as exc:
+        _log_diag(f"Extension registration failed: {exc}")
         pass