@uipath/skills 1.195.0

package/skills/uipath-agents/references/coded/lifecycle/evaluations/running-evaluations.md

@@ -0,0 +1,145 @@
+# Running Evaluations
+
+This guide covers how to execute your evaluation sets and understand the results.
+
+## Running Evaluations
+
+### Command
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> \
+  --no-report \
+  --output-file eval-results.json
+```
+
+**Parameters:**
+- `<entrypoint>` - Agent entry point name from `entry-points.json`
+- `<eval-file>` - Path to evaluation set file
+- `--workers` - Number of parallel workers (default: 1)
+- `--eval-ids` - Python/JSON-style list of evaluation case IDs to run, for example `'["test-1-basic", "test-3-edge-case"]'` (default: `[]`, meaning all cases)
+- `--no-report` - Don't report to UiPath Cloud
+- `--output-file` - Save results to JSON file
+- `--enable-mocker-cache` - Cache LLM responses for reproducibility
+
+Run a subset while debugging:
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> --no-report --eval-ids '["test-1-basic"]'
+```
+
+### Evaluation Discovery
+
+The system scans for evaluation sets in:
+
+```
+evaluations/eval-sets/*.json
+```
+
+## Understanding Results
+
+### Numeric Scores
+
+All evaluators return scores:
+
+- **1.0** - Perfect pass (evaluator criteria fully met)
+- **0.5-0.9** - Partial success (similarity-based evaluators show partial match)
+- **0.0** - Complete failure (evaluator criteria not met)
+
+### Score Interpretation
+
+**For ExactMatchEvaluator & ContainsEvaluator:**
+- 1.0 - Requirement met
+- 0.0 - Requirement not met
+
+**For Similarity-Based Evaluators (JSON, LLM Judge, Trajectory):**
+- 1.0 - Perfect match
+- 0.9-0.5 - Good match with minor differences
+- 0.4-0.1 - Weak match with significant differences
+- 0.0 - No match
+
+### Example Detailed Result
+
+```json
+{
+  "testId": "test-1-basic",
+  "testName": "Basic addition test",
+  "status": "PASSED",
+  "input": { "num1": 5, "num2": 3 },
+  "expectedOutput": { "result": 8 },
+  "actualOutput": { "result": 8 },
+  "evaluationResults": [
+    {
+      "evaluatorId": "ExactMatchEvaluator",
+      "score": 1.0,
+      "status": "PASSED",
+      "justification": "Output exactly matches expected value"
+    }
+  ]
+}
+```
+
+## Pass vs Fail
+
+A test passes if:
+- All required evaluators produce their expected scores
+- Output matches criteria for pass-fail evaluators (ExactMatch, Contains)
+- Similarity scores are above your acceptance threshold
+
+A test fails if:
+- Any evaluator criteria are not met
+- Similarity scores are below acceptable thresholds
+
+## Performance Optimization
+
+### Using Parallel Workers
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> --workers 4
+```
+
+**Worker count recommendations:**
+- `1` - Default sequential execution, useful for debugging and rate-limit-sensitive evaluators
+- `4` - Good balance for larger evaluation sets when dependencies and rate limits allow parallelism
+- Higher values - Use only when the agent, evaluators, and external services can safely handle the extra concurrency
+
+### Caching LLM Responses
+
+For evaluators using LLMs (LLMJudge, Trajectory), enable mocker cache:
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> --enable-mocker-cache
+```
+
+Benefits: Faster re-runs, reproducible results, lower API costs.
+
+## Integration with UiPath Cloud
+
+To report evaluation results to Studio Web for visualization and tracking, use `--report`. This requires authentication and `UIPATH_PROJECT_ID` set in `.env` (obtained by pushing the agent to Studio Web via `uip codedagent push`).
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> --report --workers 4
+```
+
+For local-only evaluations (no cloud connection needed), use `--no-report`:
+
+```bash
+uip codedagent eval <entrypoint> <eval-file> --no-report
+```
+
+## Troubleshooting
+
+### All Tests Fail
+- Verify agent is working correctly with `uip codedagent run`
+- Check evaluation set references correct agent
+- Ensure evaluator files exist and are valid
+- Review agent input/output schemas
+
+### Performance Issues
+- Reduce number of workers if hitting rate limits
+- Enable mocker cache for LLM evaluators
+- Run subset of tests first to debug
+
+### LLM Evaluator Issues
+- Verify API credentials are configured
+- Check model name is valid
+- Enable cache to reduce API calls

package/skills/uipath-agents/references/coded/lifecycle/file-sync.md

@@ -0,0 +1,109 @@
+# File Synchronization
+
+Sync project files between your local environment and remote Studio Web storage.
+
+## Quick Reference
+
+```bash
+# Pull remote files to local (interactive prompts on conflict)
+uip codedagent pull
+
+# Push local files to remote — mirrors local state, deletes remote files missing locally
+uip codedagent push
+
+# Force without prompts
+uip codedagent push --overwrite
+uip codedagent pull --overwrite
+
+# Push without syncing the dependency lock
+uip codedagent push --nolock
+
+# Push without syncing resource files
+uip codedagent push --ignore-resources
+```
+
+> Push **mirrors** local state — remote files not present locally are deleted. Review before pushing.
+
+## Prerequisites
+
+- Authenticated session (see [authentication](../../authentication.md)).
+- `UIPATH_PROJECT_ID` set in `.env` — verify by reading the file directly (`Read <project-dir>/.env`). The CLI reads this file at runtime; do not check `$UIPATH_PROJECT_ID` in the shell (env vars do not persist across Bash tool calls).
+
+```env
+UIPATH_PROJECT_ID=12345
+```
+
+`UIPATH_URL`, `UIPATH_ACCESS_TOKEN`, and org/tenant identifiers come from the `uip login` session automatically — do not add them to `.env`.
+
+## Pull
+
+Downloads all files from the remote Studio Web project to your local workspace, preserving directory structure.
+
+| Option | Description |
+|--------|-------------|
+| `--overwrite` | Replace conflicting local files without prompting |
+
+## Push
+
+Uploads local files to remote storage and keeps remote as an exact mirror of local state: updates differing files, adds new ones, and **removes** remote files absent locally.
+
+| Option | Description |
+|--------|-------------|
+| `--overwrite` | Skip prompts on conflict |
+| `--nolock` | Skip `uv lock` and exclude the lock file from sync |
+| `--ignore-resources` | Skip importing resources during push |
+
+## Conflict Resolution
+
+Both `push` and `pull` prompt interactively on conflict. In a non-interactive shell (CI, automation, or Claude's Bash tool) use `--overwrite` to resolve in favour of the source side.
+
+## Common Workflows
+
+**Clone a project**
+
+```bash
+echo "UIPATH_PROJECT_ID=my-project-123" > .env
+uip codedagent pull
+```
+
+**Collaborate with a shared project**
+
+```bash
+uip codedagent pull --overwrite        # pick up teammates' changes
+# edit files
+uip codedagent pull --overwrite        # re-sync immediately before pushing
+uip codedagent push --overwrite        # publish
+```
+
+`push --overwrite` replaces the remote wholesale — changes teammates pushed while you were editing will be lost. Pull again right before push to minimise the race window, or coordinate via the team instead of relying on sync alone.
+
+**CI/CD pipeline**
+
+```bash
+#!/bin/bash
+set -e
+uip codedagent pull --overwrite
+# run tests / build
+uip codedagent push --overwrite
+```
+
+## Files Involved
+
+| File | Included | Purpose |
+|------|----------|---------|
+| `pyproject.toml`, `main.py`, `.py`, `.json`, `.yaml` | yes | Project source and metadata |
+| `uipath.json`, `entry-points.json`, `bindings.json` | yes | UiPath project configuration |
+| `uv.lock` | yes (skip with `--nolock`) | Dependency lockfile |
+| `__pycache__/`, `.git/`, `.uipath/`, `.env` | no | Build artifacts, VCS, secrets |
+
+Use `packOptions` in `uipath.json` to refine what gets included.
+
+## Troubleshooting
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `UIPATH_PROJECT_ID environment variable not found` | Missing project ID in `.env` | Create a Coded Agent project in Studio Web, copy its ID, add `UIPATH_PROJECT_ID=<id>` to `.env` |
+| `Your local version is behind the remote version. Aborted!` | Push needs interactive confirmation | Use `uip codedagent push --overwrite` |
+| Push deleted unexpected files | Push mirrors local state | Review local state before pushing; use selective `--ignore-resources` to skip resource files |
+| `Conflict on pull` | Both sides changed the same files | Use `--overwrite` to take remote, or resolve manually |
+| `401 Unauthorized` | Session expired | Re-authenticate via `uip login` (see [authentication](../../authentication.md)) |

package/skills/uipath-agents/references/coded/lifecycle/local-workspace.md

@@ -0,0 +1,67 @@
+# Studio Web Local Workspace — State Reference
+
+Consult when quickstart's Project State Detection sets `project_state = local-workspace`. The lifecycle itself lives in [../quickstart.md](../quickstart.md); this file covers detection, file ownership, and recovery.
+
+## Detection
+
+An ancestor of the agent project directory contains **either** `.sw-path-marker` or `.local/folder.lock` — both are dropped by Studio Web when it actively manages the folder. A `*.uipx` solution manifest does **not** qualify on its own; every UiPath solution has one, including CLI-only and git-cloned solutions never opened in Studio Web.
+
+Inside the agent project itself: `.uipath/local-project-id.json`, `.uipath/studio_metadata.json`, and `.env` with `UIPATH_PROJECT_ID=<guid>`. These confirm but do not by themselves prove Local Workspace — they can also appear in cloud-workspace projects pulled via `uipath pull`.
+
+## Layout
+
+```
+<workspace-root>/
+└── <SolutionName>/
+    ├── .sw-path-marker              # primary detection signal
+    ├── .local/folder.lock           # primary detection signal
+    ├── <SolutionName>.uipx          # solution manifest (not LW-specific)
+    ├── resources/
+    └── <AgentDir>/                  # cd here for all uip codedagent commands
+        ├── pyproject.toml
+        ├── main.py
+        ├── <framework>.json
+        ├── entry-points.json
+        ├── bindings.json
+        ├── uipath.json
+        ├── project.uiproj
+        ├── .env
+        └── .uipath/local-project-id.json
+```
+
+## Auto-Sync
+
+`.local/folder.lock` indicates Studio Web is watching this directory and propagating local saves to the remote SW project automatically; SW-side edits flow back to the filesystem. Therefore `uip codedagent push` is **not** part of normal iteration — use `push --overwrite` / `pull --overwrite` only as recovery when sync is paused (workspace opened detached, lock expired, remote conflict).
+
+## Files Owned by Studio Web — Do Not Edit
+
+- `project.uiproj` — SW project file.
+- `.uipath/local-project-id.json`, `.uipath/studio_metadata.json` — SW sync state.
+- `.local/folder.lock` (in solution root) — SW workspace lock.
+- `<SolutionName>.uipx`, `.sw-path-marker` (in solution root) — solution manifest and SW path GUID.
+
+You own: `main.py`, `<framework>.json` (coded fields only), `pyproject.toml`, `bindings.json`, `evaluations/`, `entry-points.json` (regenerated by `init`), `uipath.json` (`packOptions`, `runtimeOptions`).
+
+## Schema Sync After Edits
+
+`entry-points.json` is generated from `main.py` — auto-sync does **not** regenerate it. After ANY edit to `main.py` that touches `Input`/`Output`/`State` Pydantic models, TypedDicts, or the entry function's signature — including adding, removing, renaming, or retyping a field — run `uip codedagent init` BEFORE `uip codedagent run`. Otherwise `entry-points.json` advertises stale schemas and the new field is invisible to the runtime and downstream consumers.
+
+Skip `init` only when the edit is purely inside node bodies / helpers (logic, prompts, business rules) and leaves every Pydantic / TypedDict shape and the entry function's signature byte-identical.
+
+## Anti-Patterns
+
+- **Do not run `uip codedagent new`** — overwrites Studio Web scaffolding and orphans the SW project ID.
+- **Do not run `uip codedagent push` as part of iteration** — auto-sync covers it; manual `push` is recovery only.
+- **Do not delete `project.uiproj`** — Studio Web requires it; auto-sync (or `pull` as fallback) will restore it.
+- **Do not change `UIPATH_PROJECT_ID` in `.env`** — it identifies the Studio Web project this folder syncs with. Changing it sends a fallback `push` to the wrong project and breaks auto-sync identity.
+- **Do not skip `uip codedagent init` after editing schemas in `main.py`** — auto-sync does not regenerate `entry-points.json`. Any `Input`/`Output`/`State` field add/remove/rename/retype, or entry-function signature change, requires `init` before `run`. See § Schema Sync After Edits.
+
+## Troubleshooting
+
+| Error | Cause | Fix |
+|---|---|---|
+| `uipath executable not found` on `run` / `eval` | `.venv` not created or `setup --force` not run after creating it | Run quickstart step 2's `local-workspace` venv prep block |
+| Local edit not visible in Studio Web after a few seconds | Auto-sync paused (workspace detached, lock expired, network glitch) | Re-open the workspace in Studio Web; if still missing, `uip codedagent push --overwrite` once to reconcile |
+| `Your local version is behind the remote version. Aborted!` on a fallback `push` | SW or another local session edited the project while auto-sync was paused | `uip codedagent pull --overwrite`, reconcile, then `push --overwrite` |
+| `UIPATH_PROJECT_ID environment variable not found` on a fallback `push` | `.env` missing or `UIPATH_PROJECT_ID` removed | Restore from `.uipath/local-project-id.json`'s `projectId`; auto-sync will reconstitute `.env` after the next save |
+| `401 Unauthorized` on a fallback `push` or on `eval --report` | Session expired | Re-authenticate per [../../authentication.md](../../authentication.md) |

package/skills/uipath-agents/references/coded/lifecycle/running-agents.md

@@ -0,0 +1,92 @@
+# Run UiPath Agents
+
+Execute agents locally for testing or invoke published agents in UiPath Cloud.
+
+## Quick Reference
+
+```bash
+# Run locally — ENTRYPOINT is the name from entry-points.json, NOT the project name
+uip codedagent run <ENTRYPOINT> '{"query": "test"}'
+
+# Run with file input
+uip codedagent run <ENTRYPOINT> --input-file input.json
+
+# Interactive dev loop (prompts for input, hot-reloads on changes)
+uip codedagent dev
+
+# Invoke published agent in cloud
+uip codedagent invoke <ENTRYPOINT> '{"query": "test"}'
+```
+
+The entrypoint name comes from `entry-points.json` (e.g., `main`, `agent`) — not the project or package name. Each framework seeds that name from its own config file:
+
+| Framework | Source of truth | Key in the file |
+|---|---|---|
+| Coded Function | `uipath.json` | `functions` |
+| LangGraph | `langgraph.json` | `graphs` |
+| LlamaIndex | `llama_index.json` | `workflows` |
+| OpenAI Agents | `openai_agents.json` | `agents` |
+
+`uip codedagent init` consolidates these into `entry-points.json` — the authoritative list to pick from.
+
+## Prerequisites
+
+- `entry-points.json` exists (run `uip codedagent init`).
+- For `invoke`: the agent is published and an authenticated session is active.
+
+## Run vs Dev vs Invoke
+
+| Aspect | Run (one-shot local) | Dev (interactive local) | Invoke (Cloud) |
+|--------|---|---|---|
+| Purpose | Execute once with a given input | Iterate on the agent with hot-reload and prompted input | Execute a deployed agent in UiPath Cloud |
+| Location | Your machine | Your machine | UiPath Cloud workspace |
+| When to use | CI, scripted tests, one-off checks | Active development / debugging | After `uip codedagent deploy` |
+| Command | `uip codedagent run <ENTRYPOINT> '<input>'` | `uip codedagent dev` | `uip codedagent invoke <ENTRYPOINT> '<input>'` |
+
+`uip codedagent dev` always runs interactively (the wrapper appends `--interactive` automatically) — use it for REPL-style work, not inside non-interactive scripts.
+
+## Run (Local)
+
+Reads `entry-points.json` to discover available entrypoints and their schemas. If multiple exist, prompts for selection. JSON input must conform to the selected entrypoint's input schema.
+
+Results are printed as a formatted panel:
+
+```
+EXECUTION RESULTS
+═══════════════════════════════════════════════════════════
+
+Status:           ✅ SUCCESS
+Execution Time:   0.45 seconds
+Agent:            my-agent (agent.py:run)
+Input:            {"action": "process", "data": "sample"}
+
+OUTPUT:
+{
+  "status": "completed",
+  "result": "processed successfully"
+}
+```
+
+Execution traces are collected automatically and can be viewed in UiPath Cloud.
+
+## Invoke (Cloud)
+
+```bash
+uip codedagent invoke <ENTRYPOINT> '<json-input>'
+```
+
+- `<ENTRYPOINT>` — entrypoint path (optional; defaults to the first entrypoint)
+- `<json-input>` — JSON input matching the entrypoint's schema (default `{}`)
+
+The CLI reads project name and version from `pyproject.toml`, looks up the published release in your UiPath workspace, starts a cloud job with the provided input, and returns a monitoring URL.
+
+`invoke` is **asynchronous** — the command returns immediately with a monitoring URL. Open it to see the job's status, logs, and results. There is no `--wait` flag.
+
+## Troubleshooting
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `Authorization required` / missing session | Not authenticated | Run `uip login` — see [authentication](../../authentication.md) |
+| `UIPATH_ORGANIZATION_ID...is required` | Missing org ID env variable (OpenAI Agents only) | Ensure a valid `uip login` session; the wrapper injects org ID automatically |
+| `Invalid input` | JSON doesn't match the input schema | Check `entry-points.json` for expected fields and types |
+| `Error during initialization: File not found: main` | `main.py` missing or not in project root | Create `main.py` in the project root |

package/skills/uipath-agents/references/coded/lifecycle/setup.md

@@ -0,0 +1,126 @@
+# Setup UiPath Agent Project
+
+## Preflight
+
+```bash
+python --version                                           # 3.11, 3.12, or 3.13
+which uv  > /dev/null 2>&1 || echo "install uv:  curl -LsSf https://astral.sh/uv/install.sh | sh"
+which uip > /dev/null 2>&1 || echo "install uip: npm install -g @uipath/cli"
+```
+
+## Framework Selection
+
+Pick the framework before starting. The package installed in the Workflow determines which scaffold `uip codedagent new` produces.
+
+| Agent Type | `<FRAMEWORK_PACKAGE>` | Framework config | Guide |
+|---|---|---|---|
+| Coded Function | `uipath` | `uipath.json` | [coded-function-agents.md](../frameworks/coded-function-agents.md) |
+| LangGraph | `"uipath-langchain"` | `langgraph.json` | [langgraph-integration.md](../frameworks/langgraph-integration.md) |
+| LlamaIndex | `uipath-llamaindex` | `llama_index.json` | [llamaindex-integration.md](../frameworks/llamaindex-integration.md) |
+| OpenAI Agents | `uipath-openai-agents` | `openai_agents.json` | [openai-agents-integration.md](../frameworks/openai-agents-integration.md) |
+
+## Starting Points
+
+| Starting from | Use |
+|---|---|
+| Empty directory | The Workflow below |
+| Existing UiPath agent (has `main.py` + `<framework>.json` + UiPath deps) | `source .venv/bin/activate`, then `uip codedagent setup --force && uip codedagent init` only |
+| Existing Python agent (has `main.py`, missing UiPath deps / framework config) | `source .venv/bin/activate`, `uv add <FRAMEWORK_PACKAGE>`, adapt `main.py` per the framework guide, then `uip codedagent setup --force && uip codedagent init` |
+| Studio Web Local Workspace solution (ancestor contains `.sw-path-marker` or `.local/folder.lock`) | Already scaffolded by Studio Web. One-time local-run prep: `uv venv --python 3.13`, activate, `uv sync`, `uip codedagent setup --force`. Do **not** run `uip codedagent new`. Re-run `init` after every edit that adds/removes/renames/retypes a field on `Input`/`Output`/`State` or changes the entry-function signature — see [local-workspace.md](local-workspace.md) § Schema Sync After Edits for the full rule and anti-patterns. |
+
+## Workflow
+
+```bash
+mkdir <PROJECT_NAME> && cd <PROJECT_NAME>
+uv venv --python 3.13                        # uv defaults to the latest Python; pin to a UiPath-supported version
+source .venv/bin/activate                    # Windows: .venv\Scripts\activate
+uv pip install <FRAMEWORK_PACKAGE>
+uip codedagent setup --force
+uip codedagent new <PROJECT_NAME>
+uv add uipath-dev --dev                      # required by `uip codedagent dev` (local dev web server)
+uv sync
+uip codedagent init
+```
+
+`uipath-dev` is added to the dev dependency group during scaffold so `uip codedagent dev` works later without a second install pass. Skipping it causes `uip codedagent dev` to fail with *"The 'uipath-dev' package is required to use the dev command"*.
+
+## Coded Function Agents
+
+`uipath.json` carries the entrypoint mapping:
+
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+Edit the scaffolded `main.py`'s `Input` / `Output` models and `async def main` to fit the real agent.
+
+## Generated Files
+
+| File | Purpose |
+|---|---|
+| `pyproject.toml` | Project metadata and dependencies |
+| `main.py` | Agent entrypoint |
+| `<framework>.json` | Framework config (LangGraph / LlamaIndex / OpenAI Agents) |
+| `uipath.json` | Runtime options, pack options, `functions` map |
+| `entry-points.json` | Input / output schemas from Pydantic models |
+| `bindings.json` | Runtime bindings |
+| `uv.lock` | Dependency lockfile |
+| `.uipath/telemetry.json` | Telemetry configuration |
+| `AGENTS.md`, `.agent/` | Documentation |
+
+## `uipath.json`
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {}
+}
+```
+
+**Key fields:**
+- **`runtimeOptions.isConversational`** - Set `true` for conversational/chat agents
+- **`packOptions`** - Control which files are included when packaging for deployment
+- **`functions`** - Entrypoint mappings (format: `"file_path:function_name"`)
+
+### `packOptions.directoriesExcluded` for solution context
+
+When the agent project is registered in a solution and uploaded via `uip solution upload`, the agent directory is bundled into the solution archive. Set `directoriesExcluded` to keep Python build artifacts out of the archive:
+
+```json
+"packOptions": {
+  "directoriesExcluded": [".venv", "__pycache__"],
+  "includeUvLock": true
+}
+```
+
+`.venv/` is hundreds of MB of installed wheels and breaks uploads. `__pycache__/` is ephemeral bytecode. Both regenerate from `pyproject.toml` + `uv.lock` on the target side. Without these exclusions, `uip solution upload` produces an oversized archive that can be rejected by Studio Web.
+
+- `isConversational: true` for chat-style agents.
+- `packOptions` controls `.nupkg` contents at deploy time.
+
+## Troubleshooting
+
+| Error | Cause | Fix |
+|---|---|---|
+| `uipath executable not found` | `setup` not run, or run without venv activated | Activate `.venv` and re-run `uip codedagent setup --force` |
+| UiPath CLI/Python executable is not recognized, or `uipathExePath` is stale | The CLI still points at an old or missing virtualenv executable | Run `source .venv/bin/activate`, then `uip codedagent setup --force` to refresh `uipathExePath` |
+| `Found .venv in current directory but no virtual environment is activated` | `.venv` exists but `VIRTUAL_ENV` is unset | Activate `.venv` first, then re-run `uip codedagent setup --force` |
+| `No compatible Python installation found` | Python outside 3.11 – 3.13 | Install 3.11, 3.12, or 3.13 (or set `PYTHON_TOOL_PYTHON_VERSIONS`) |
+| `Project authors cannot be empty` | Missing `authors` in `pyproject.toml` | Add `authors = [{ name = "Your Name" }]` to `[project]` |
+| `NameError` during `init` | Framework not installed when `init` imports `main.py` | Run `uv sync` before `uip codedagent init` |
+| `No entrypoints found in uipath.json` | Framework config or package missing | Verify `uv pip install` succeeded, then re-run `uip codedagent init` |
+| `ModuleNotFoundError` for a package you just installed, even after activating `.venv` | A shell `python` alias points at a different interpreter (uv-managed, system, etc.) | Use `.venv/bin/python` directly for sanity checks, or `unalias python` for the session |