kolega-code 0.26.0__tar.gz → 0.26.2__tar.gz

{kolega_code-0.26.0 → kolega_code-0.26.2}/CHANGELOG.md

@@ -6,6 +6,67 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.26.2 - 2026-07-31
+
+### Added
+
+- `kolega-code ask --gigacode` enables gigacode workflow orchestration in
+  headless runs, matching the TUI's `/gigacode` toggle: the `run_workflow` and
+  `list_workflow_runs` tools are exposed and the authoring guide is injected.
+  The setting persists with the session, so `ask --session <id>` resumes with
+  gigacode still on.
+
+### Changed
+
+- Gigacode's concurrent-worker cap is now a flat 8 instead of being derived from
+  the host's core count. Workers wait on provider responses rather than CPU, so
+  the old formula only made fan-out width vary with the machine — and collapse to
+  a single serial worker on a one-CPU host or container.
+
+## 0.26.1 - 2026-07-31
+
+### Fixed
+
+- Gigacode resume now matches cached `agent()` results by call content instead
+  of call position, so completed work no longer re-runs after `pipeline()`
+  timing drift or script edits that shift call positions (one production resume
+  had salvaged only 6 of 91 completed calls). Resumed runs also journal what
+  they replayed, making a resume of a resume exact, and a duplicate `agent()`
+  label now logs a one-time authoring hint. Existing journals work unchanged.
+- Workflow scripts now have a designated drafting location. The authoring
+  guide and `script_path` docs direct models to draft long scripts in the
+  session scratchpad instead of the project working tree — generated scripts
+  in the repo pollute `git status` and go stale for later sessions. The
+  executed script is persisted under the run directory either way.
+- Workflow token budgets are harder to undersize by accident. The
+  `token_budget` schema, tool docstrings, and authoring guide now carry
+  evidence-based sizing anchors (measured across real runs: review calls
+  median ~6k/p90 ~24k output tokens, coder calls median ~20k/p90 ~80k,
+  reasoning included — size as review_calls × 15k + coder_calls × 50k,
+  doubled, or omit), the run warns in the progress log at 75% and 90% spend,
+  and a run
+  that dies on budget exhaustion tells the model in its tool result that it is
+  resumable — with the exact `resume_from_run_id` call and the count of
+  journaled calls that will replay free.
+- Workflow fan-out failures are no longer silent. A `pipeline()` stage or
+  `parallel()` thunk that raises still drops its item to `None`, but the drop
+  is now reported live in the progress log and recorded in the transcript with
+  the exception and the offending script line; the `run_workflow` result warns
+  with an aggregate (e.g. `AttributeError at script line 299 (x6)`) and
+  `run.json` records `script_exception_drops`. A fan-out that comes back all
+  `None` with drops is called out as a likely script bug. Budget and agent-cap
+  exhaustion now propagate out of fan-outs and fail the run (cancelling and
+  draining the remaining chains) instead of shredding it into `None`s —
+  previously a run could report `completed` after a script bug silently
+  discarded every result.
+- An interrupted gigacode workflow's run id is now recoverable. Runs are
+  stamped with their owning session, cancelling a turn marks the run
+  `interrupted` in `run.json`, and the new session-scoped `list_workflow_runs`
+  tool lists this session's runs (status, tokens, journaled calls, artifact
+  paths) so the agent can resume an interrupted run with `resume_from_run_id`
+  instead of re-running it from scratch — previously the run id was only
+  returned on normal completion, so an interrupted run's journal was orphaned.
+
 ## 0.26.0 - 2026-07-31
 
 ### Added

{kolega_code-0.26.0 → kolega_code-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.0
+Version: 0.26.2
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/
@@ -278,7 +278,7 @@ Description-Content-Type: text/markdown
 
 # Kolega Code
 
-**Multi-agent coding in the terminal.**
+**A terminal coding agent where the model writes its own multi-agent workflows.**
 
 [![PyPI version](https://img.shields.io/pypi/v/kolega-code)](https://pypi.org/project/kolega-code/)
 [![Python versions](https://img.shields.io/pypi/pyversions/kolega-code)](https://pypi.org/project/kolega-code/)
@@ -288,67 +288,73 @@ Description-Content-Type: text/markdown
 [![Docs](https://img.shields.io/badge/docs-kolega--ai.github.io-blue)](https://kolega-ai.github.io/kolega-code/)
 [![Changelog](https://img.shields.io/badge/changelog-keep%20up-blue)](CHANGELOG.md)
 
-Kolega Code is a local-first terminal coding agent built for work that is too wide
-for one loop: fan out specialized sub-agents with **Gigacode**, route different
-models to different jobs, search the web, drive a browser, and keep sessions,
-settings, permissions, and credentials on your machine.
+Kolega Code is a local-first terminal coding agent. For work that is too broad
+for one agent loop, its **Gigacode** engine has the model write a Python program
+that orchestrates multiple sub-agents. The runtime then executes that program.
 
 ![Kolega Code in action](docs/src/assets/demo.gif)
 
-## Built for work one agent cannot cover
-
-Most terminal agents are strongest when one model can reason through one task at a
-time. Kolega Code keeps that familiar workflow, then adds orchestration for broad work:
-large audits, sweeping migrations, cross-file checks, adversarial reviews, and
-implementation plans whose pieces can run independently.
-
-With [Gigacode](https://kolega-ai.github.io/kolega-code/gigacode/), Kolega Code can:
-
-- **Fan out many sub-agents at once.** Split a wide codebase review by package,
-  assign independent implementation tasks, or run checks across many directories in
-  parallel.
-- **Use real workflow shapes.** The agent can generate parallel phases, pipelines,
-  loops, judge panels, and synthesis steps instead of only delegating one task at a
-  time.
-- **Keep orchestration visible.** Workflow phase headers and progress lines appear
-  in the transcript; the sub-agent inspector shows each agent's live trajectory.
-- **Save inspectable artifacts.** Each run keeps the generated workflow script,
-  result files, a Markdown transcript, raw JSONL, a resume journal, and debug
-  sub-agent transcripts under Kolega Code's state directory.
-- **Run in either mode.** In Plan mode, workflow sub-agents stay read-only for
-  parallel investigation. In Build mode, they can use the full coding toolset.
-- **Resume interrupted runs.** Finished workflow steps are journaled so a deliberate
-  resume does not have to restart the whole fan-out.
-
-Use normal chat for focused changes. Turn on Gigacode when the problem is broad
-enough that one serial agent pass would be the bottleneck.
-
-## Features
-
-- **Gigacode orchestration:** parallel, pipelined, looped, judged, and synthesized
-  multi-agent workflows with saved artifacts and resume support.
-- **Specialized sub-agents:** planning, building/coder, investigation, general, and
-  browser agents, with live activity tracking in the TUI.
-- **Repo tools:** read and search code, create files, apply precise edits, and inspect
-  session changes/diffs.
-- **Terminal execution:** run shell commands with streamed output and project-level
-  permission controls.
-- **Plan/build workflow:** use read-only Plan mode for investigation and a reviewable
-  task list, then Build mode to implement.
-- **Web search and browsing:** DuckDuckGo works by default with no key; Firecrawl,
-  Tavily, and SearXNG are configurable search backends. Kolega Code can also fetch URLs
-  directly and use a Playwright-powered browser agent for interactive sites.
-- **MCP servers:** connect verified `streamable_http`, `sse`, and `stdio` MCP servers
+## Gigacode: model-authored orchestration
+
+For a repo-wide review, a migration, or a plan with independent workstreams, the
+model writes an orchestration program instead of delegating workers one at a
+time. The program can combine parallel phases, pipelines, adversarial
+verification, judge panels, and synthesis gates to fit the task. The runtime
+saves the script so it can be inspected and run again.
+
+Claude Code uses the same model-authored approach for its dynamic workflows
+(ultracode). Kolega Code provides an open, provider-agnostic implementation
+whose runtime source is available in this repository.
+
+The runtime journals each completed agent call to disk. Resume is content-keyed
+rather than positional: when you use `resume_from_run_id`, calls with unchanged
+semantic inputs replay from the journal at zero token cost. This still works if
+the script was edited or reordered, and it works across sessions and process
+restarts.
+
+Read [how gigacode works](how-gigacode-works.md) for the architecture, or an
+[unedited model-authored workflow](examples/parallel-code-review.py) with its
+full provenance and execution record.
+
+## How it works
+
+The model investigates your repo, then writes a Python program against a small
+runtime API (`agent`, `parallel`, `pipeline`, `phase`, `budget`). The runtime
+enforces concurrency caps, an agent-count backstop, and token-budget accounting.
+It dispatches typed sub-agents, including read-only investigators, coders, and
+browser agents, whose activity streams into the TUI's sub-agent inspector.
+
+As the run progresses, the runtime writes the script, per-call results,
+transcripts, and final result to disk. An interrupted or budget-capped run keeps
+its journal and can be resumed, with unchanged calls replaying free. The
+mechanics, guarantees, and limitations are documented in
+[how-gigacode-works.md](how-gigacode-works.md).
+
+## The rest of the agent
+
+Gigacode is off by default. Enable it with `/gigacode on`. For focused changes,
+use Kolega Code as an ordinary terminal coding agent:
+
+- **Plan/Build modes:** read-only Plan mode for investigation and a reviewable
+  task list, Build mode to implement (`Shift+Tab` to switch). In Plan mode,
+  workflow sub-agents are forced read-only too.
+- **Repo tools:** read and search code, create files, apply precise edits, and
+  inspect session changes/diffs.
+- **Terminal execution:** run shell commands with streamed output and
+  project-level permission controls.
+- **Web search and browsing:** DuckDuckGo by default with no key; Firecrawl,
+  Tavily, and SearXNG configurable; direct URL fetch; a Playwright-powered
+  browser agent for interactive sites.
+- **MCP servers:** connect `streamable_http`, `sse`, and `stdio` MCP servers
   (including OAuth-enabled HTTP servers) as permission-gated tools.
-- **Model routing:** choose provider/model combinations, set thinking effort, split
-  long-context/fast/thinking roles, and override models per agent role.
-- **Interactive or scriptable:** use the Textual TUI, queue follow-up prompts
-  while the agent is working, run `kolega-code ask`, request JSON output,
-  list/export/resume sessions, and diagnose setup with `doctor`.
-- **Extensibility:** add agent skills, override prompts with project templates, run
-  lifecycle hooks, and persist project permission rules.
-- **Local-first state:** sessions, settings, permissions, OAuth tokens, and API-key
-  settings stay on your machine with restrictive permissions where applicable.
+- **Interactive or scriptable:** Textual TUI with queued follow-ups, one-shot
+  `kolega-code ask` with JSON output, session list/export/resume, `doctor`.
+- **Extensibility:** agent skills, project prompt-template overrides
+  ([docs](https://kolega-ai.github.io/kolega-code/configuration/prompt-overrides/)),
+  lifecycle hooks, persistent project permission rules.
+- **Local-first state:** sessions, settings, permissions, OAuth tokens, and
+  API-key settings stay on your machine with restrictive permissions where
+  applicable.
 
 ## Quick start
 
@@ -378,9 +384,9 @@ kolega-code .
 ```
 
 **3. Connect a model.** Complete the first-run wizard with ChatGPT sign-in or an
-API key. Later, open the categorized Settings screen from the sidebar or with
-`/settings`. Use `Shift+Tab` to switch between **Plan** and **Build** mode, or run
-`/gigacode on` when a task is broad enough for fan-out.
+API key. Later, open Settings from the sidebar or with `/settings`. Use
+`Shift+Tab` to switch between **Plan** and **Build** mode, or run `/gigacode on`
+when a task is broad enough for fan-out.
 
 Resume a previous conversation:
 
@@ -396,7 +402,7 @@ kolega-code . --resume <id>       # a specific Resume ID from `sessions list`
 | **Interactive TUI** | `kolega-code .` | Day-to-day development, exploration, orchestration |
 | **One-shot** | `kolega-code ask "…"` | Scripting, automation, quick questions, CI |
 
-There are also helper commands for managing sessions and checking your setup:
+Helper commands for sessions and setup:
 
 ```bash
 kolega-code ask "summarize this repository" --project .
@@ -404,10 +410,14 @@ kolega-code sessions list --project .
 kolega-code doctor --project .
 ```
 
-## Supported providers
+## Models and routing
 
-Kolega Code supports a broad model-provider catalog and lets you route models by
-role instead of forcing one model to do every job.
+Kolega Code can route models by role. You can use a strong long-context model
+for the main loop, a faster model for utility calls, and a dedicated model for
+extended thinking. Per-agent-role overrides are available for planning,
+building, investigation, general, and browser agents. A Gigacode workflow can
+also pin cheaper models to individual calls with `model_override`, allowing one
+model to write the orchestration while cheaper models run its agents.
 
 Supported model providers:
 
@@ -428,38 +438,21 @@ Supported model providers:
 - Ollama Cloud
 - local Llama
 
-Supported web-search backends:
-
-- DuckDuckGo — default, no key required
-- Firecrawl
-- Tavily
-- SearXNG — self-hosted option
+With a paid **ChatGPT** plan (Plus, Pro, or Business), `/login chatgpt` runs
+OpenAI models without a separate API key; tokens are stored locally (chmod `600`)
+and refreshed automatically. See
+[Sign in with ChatGPT](https://kolega-ai.github.io/kolega-code/configuration/sign-in-with-chatgpt/).
 
+Web search backends include DuckDuckGo (the default, with no key), Firecrawl,
+Tavily, and self-hosted SearXNG. Choose one in Settings or with
+`KOLEGA_CODE_WEB_SEARCH_BACKEND`.
 See [Providers & Models](https://kolega-ai.github.io/kolega-code/configuration/providers-and-models/)
 for model IDs, role configuration, API-key variables, and thinking-effort options.
 
-## Model routing
-
-Kolega Code can assign different models to different operational roles: a strong
-long-context model for the main coding loop, a faster model for utility calls, and
-a dedicated model for extended thinking. You can also override models per agent
-role — planning, building, investigation, general, and browser — so wide workflows
-can use cheaper models where they fit and stronger models where they matter.
-
-## Sign in with ChatGPT
-
-If you have a paid **ChatGPT** plan (Plus, Pro, or Business), you can use it to run
-OpenAI models instead of a separate API key. Run `/login chatgpt` in the TUI,
-complete the browser sign-in, and Kolega Code switches to the **OpenAI (ChatGPT
-subscription)** provider (default `gpt-5.6-sol`). Tokens are stored locally (chmod
-`600`) and refreshed automatically; `/logout chatgpt` removes them. See
-[Sign in with ChatGPT](https://kolega-ai.github.io/kolega-code/configuration/sign-in-with-chatgpt/).
-
 ## Configuration
 
-Set your provider, model, and API keys from first-run onboarding or the full-screen
-Settings editor in the UI, or via environment variables and flags for
-non-interactive use:
+Set provider, model, and API keys from onboarding or the Settings editor, or via
+environment variables and flags for non-interactive use:
 
 ```bash
 export KOLEGA_CODE_PROVIDER=deepseek
@@ -467,24 +460,12 @@ export DEEPSEEK_API_KEY=...
 kolega-code ask "summarize this repository" --project . --provider deepseek --model deepseek-v4-pro
 ```
 
-API key variables only provide credentials — pick a provider/model explicitly or
-save one in Settings. Local session state lives under your platform's state
+API key variables only provide credentials. Pick a provider and model explicitly
+or save them in Settings. Local session state lives under your platform's state
 directory unless `KOLEGA_CODE_STATE_DIR` is set. See the
 [Configuration docs](https://kolega-ai.github.io/kolega-code/configuration/settings-and-api-keys/)
 for the full story.
 
-The `web_search` tool uses DuckDuckGo by default without a key. To choose another
-backend, set it in **Settings** or export `KOLEGA_CODE_WEB_SEARCH_BACKEND` as
-`firecrawl`, `tavily`, or `searxng`; use `FIRECRAWL_API_KEY`, `TAVILY_API_KEY`, or
-`SEARXNG_BASE_URL` as needed.
-
-Projects can override Kolega Code's base prompts with uppercase Markdown templates
-in `.kolega/prompts/`. Generate editable starters with Jinja replacement tags using
-`/prompts dump` in the TUI or `kolega-code prompts dump --project .` in a terminal.
-To dump only selected starters, pass prompt names such as `coder`, `planning`, or
-`compaction` (filename aliases like `CODER.md` work too). Validate existing
-overrides with `/prompts validate` or `kolega-code prompts validate --project .`.
-
 ## Requirements
 
 - **Python 3.11+**
@@ -493,8 +474,12 @@ overrides with `/prompts validate` or `kolega-code prompts validate --project .`
 
 ## Documentation
 
+This repo includes the [Gigacode architecture document](how-gigacode-works.md)
+and an [unedited model-authored example workflow](examples/parallel-code-review.py).
+
 Full documentation lives at **[kolega-ai.github.io/kolega-code](https://kolega-ai.github.io/kolega-code/)**:
 
+- [Gigacode user guide](https://kolega-ai.github.io/kolega-code/gigacode/)
 - [Quick Start](https://kolega-ai.github.io/kolega-code/getting-started/quick-start/)
 - [CLI overview](https://kolega-ai.github.io/kolega-code/cli/overview/)
 - [How it works & concepts](https://kolega-ai.github.io/kolega-code/concepts/how-it-works/)

kolega_code-0.26.2/README.md

@@ -0,0 +1,227 @@
+# Kolega Code
+
+**A terminal coding agent where the model writes its own multi-agent workflows.**
+
+[![PyPI version](https://img.shields.io/pypi/v/kolega-code)](https://pypi.org/project/kolega-code/)
+[![Python versions](https://img.shields.io/pypi/pyversions/kolega-code)](https://pypi.org/project/kolega-code/)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
+[![CI](https://github.com/kolega-ai/kolega-code/actions/workflows/ci.yml/badge.svg)](https://github.com/kolega-ai/kolega-code/actions/workflows/ci.yml)
+[![Coverage](docs/src/assets/coverage.svg)](https://github.com/kolega-ai/kolega-code/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-kolega--ai.github.io-blue)](https://kolega-ai.github.io/kolega-code/)
+[![Changelog](https://img.shields.io/badge/changelog-keep%20up-blue)](CHANGELOG.md)
+
+Kolega Code is a local-first terminal coding agent. For work that is too broad
+for one agent loop, its **Gigacode** engine has the model write a Python program
+that orchestrates multiple sub-agents. The runtime then executes that program.
+
+![Kolega Code in action](docs/src/assets/demo.gif)
+
+## Gigacode: model-authored orchestration
+
+For a repo-wide review, a migration, or a plan with independent workstreams, the
+model writes an orchestration program instead of delegating workers one at a
+time. The program can combine parallel phases, pipelines, adversarial
+verification, judge panels, and synthesis gates to fit the task. The runtime
+saves the script so it can be inspected and run again.
+
+Claude Code uses the same model-authored approach for its dynamic workflows
+(ultracode). Kolega Code provides an open, provider-agnostic implementation
+whose runtime source is available in this repository.
+
+The runtime journals each completed agent call to disk. Resume is content-keyed
+rather than positional: when you use `resume_from_run_id`, calls with unchanged
+semantic inputs replay from the journal at zero token cost. This still works if
+the script was edited or reordered, and it works across sessions and process
+restarts.
+
+Read [how gigacode works](how-gigacode-works.md) for the architecture, or an
+[unedited model-authored workflow](examples/parallel-code-review.py) with its
+full provenance and execution record.
+
+## How it works
+
+The model investigates your repo, then writes a Python program against a small
+runtime API (`agent`, `parallel`, `pipeline`, `phase`, `budget`). The runtime
+enforces concurrency caps, an agent-count backstop, and token-budget accounting.
+It dispatches typed sub-agents, including read-only investigators, coders, and
+browser agents, whose activity streams into the TUI's sub-agent inspector.
+
+As the run progresses, the runtime writes the script, per-call results,
+transcripts, and final result to disk. An interrupted or budget-capped run keeps
+its journal and can be resumed, with unchanged calls replaying free. The
+mechanics, guarantees, and limitations are documented in
+[how-gigacode-works.md](how-gigacode-works.md).
+
+## The rest of the agent
+
+Gigacode is off by default. Enable it with `/gigacode on`. For focused changes,
+use Kolega Code as an ordinary terminal coding agent:
+
+- **Plan/Build modes:** read-only Plan mode for investigation and a reviewable
+  task list, Build mode to implement (`Shift+Tab` to switch). In Plan mode,
+  workflow sub-agents are forced read-only too.
+- **Repo tools:** read and search code, create files, apply precise edits, and
+  inspect session changes/diffs.
+- **Terminal execution:** run shell commands with streamed output and
+  project-level permission controls.
+- **Web search and browsing:** DuckDuckGo by default with no key; Firecrawl,
+  Tavily, and SearXNG configurable; direct URL fetch; a Playwright-powered
+  browser agent for interactive sites.
+- **MCP servers:** connect `streamable_http`, `sse`, and `stdio` MCP servers
+  (including OAuth-enabled HTTP servers) as permission-gated tools.
+- **Interactive or scriptable:** Textual TUI with queued follow-ups, one-shot
+  `kolega-code ask` with JSON output, session list/export/resume, `doctor`.
+- **Extensibility:** agent skills, project prompt-template overrides
+  ([docs](https://kolega-ai.github.io/kolega-code/configuration/prompt-overrides/)),
+  lifecycle hooks, persistent project permission rules.
+- **Local-first state:** sessions, settings, permissions, OAuth tokens, and
+  API-key settings stay on your machine with restrictive permissions where
+  applicable.
+
+## Quick start
+
+**1. Install** with the script:
+
+```bash
+curl -fsSL https://kolega.dev/install-kolega-code.sh | sh
+```
+
+Or with [uv](https://docs.astral.sh/uv/) (or `pip`):
+
+```bash
+uv tool install kolega-code
+# or: pip install kolega-code
+```
+
+Verify the install:
+
+```bash
+kolega-code --version
+```
+
+**2. Start a session** in your project:
+
+```bash
+kolega-code .
+```
+
+**3. Connect a model.** Complete the first-run wizard with ChatGPT sign-in or an
+API key. Later, open Settings from the sidebar or with `/settings`. Use
+`Shift+Tab` to switch between **Plan** and **Build** mode, or run `/gigacode on`
+when a task is broad enough for fan-out.
+
+Resume a previous conversation:
+
+```bash
+kolega-code . --resume            # latest session
+kolega-code . --resume <id>       # a specific Resume ID from `sessions list`
+```
+
+## Two ways to use it
+
+| Mode | Command | Best for |
+| --- | --- | --- |
+| **Interactive TUI** | `kolega-code .` | Day-to-day development, exploration, orchestration |
+| **One-shot** | `kolega-code ask "…"` | Scripting, automation, quick questions, CI |
+
+Helper commands for sessions and setup:
+
+```bash
+kolega-code ask "summarize this repository" --project .
+kolega-code sessions list --project .
+kolega-code doctor --project .
+```
+
+## Models and routing
+
+Kolega Code can route models by role. You can use a strong long-context model
+for the main loop, a faster model for utility calls, and a dedicated model for
+extended thinking. Per-agent-role overrides are available for planning,
+building, investigation, general, and browser agents. A Gigacode workflow can
+also pin cheaper models to individual calls with `model_override`, allowing one
+model to write the orchestration while cheaper models run its agents.
+
+Supported model providers:
+
+- Anthropic
+- OpenAI API
+- OpenAI via ChatGPT subscription sign-in
+- Google
+- Groq
+- Together.ai
+- Fireworks.ai
+- xAI / Grok
+- DashScope / Qwen
+- OpenRouter (gateway to 250+ tool-capable models)
+- Moonshot / Kimi
+- DeepSeek
+- Z.AI / GLM Coding Plan
+- Kimi Coding Plan
+- Ollama Cloud
+- local Llama
+
+With a paid **ChatGPT** plan (Plus, Pro, or Business), `/login chatgpt` runs
+OpenAI models without a separate API key; tokens are stored locally (chmod `600`)
+and refreshed automatically. See
+[Sign in with ChatGPT](https://kolega-ai.github.io/kolega-code/configuration/sign-in-with-chatgpt/).
+
+Web search backends include DuckDuckGo (the default, with no key), Firecrawl,
+Tavily, and self-hosted SearXNG. Choose one in Settings or with
+`KOLEGA_CODE_WEB_SEARCH_BACKEND`.
+See [Providers & Models](https://kolega-ai.github.io/kolega-code/configuration/providers-and-models/)
+for model IDs, role configuration, API-key variables, and thinking-effort options.
+
+## Configuration
+
+Set provider, model, and API keys from onboarding or the Settings editor, or via
+environment variables and flags for non-interactive use:
+
+```bash
+export KOLEGA_CODE_PROVIDER=deepseek
+export DEEPSEEK_API_KEY=...
+kolega-code ask "summarize this repository" --project . --provider deepseek --model deepseek-v4-pro
+```
+
+API key variables only provide credentials. Pick a provider and model explicitly
+or save them in Settings. Local session state lives under your platform's state
+directory unless `KOLEGA_CODE_STATE_DIR` is set. See the
+[Configuration docs](https://kolega-ai.github.io/kolega-code/configuration/settings-and-api-keys/)
+for the full story.
+
+## Requirements
+
+- **Python 3.11+**
+- An **API key**, ChatGPT sign-in, or local model for at least one supported model provider
+- A terminal that supports a modern TUI (most do)
+
+## Documentation
+
+This repo includes the [Gigacode architecture document](how-gigacode-works.md)
+and an [unedited model-authored example workflow](examples/parallel-code-review.py).
+
+Full documentation lives at **[kolega-ai.github.io/kolega-code](https://kolega-ai.github.io/kolega-code/)**:
+
+- [Gigacode user guide](https://kolega-ai.github.io/kolega-code/gigacode/)
+- [Quick Start](https://kolega-ai.github.io/kolega-code/getting-started/quick-start/)
+- [CLI overview](https://kolega-ai.github.io/kolega-code/cli/overview/)
+- [How it works & concepts](https://kolega-ai.github.io/kolega-code/concepts/how-it-works/)
+- [Configuration](https://kolega-ai.github.io/kolega-code/configuration/settings-and-api-keys/)
+
+## Project resources
+
+- [Documentation](https://kolega-ai.github.io/kolega-code/)
+- [Releases](https://github.com/kolega-ai/kolega-code/releases)
+- [Changelog](CHANGELOG.md)
+- [Contributing](CONTRIBUTING.md)
+- [Security policy](SECURITY.md)
+- [Issue tracker](https://github.com/kolega-ai/kolega-code/issues)
+
+## Contributing
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup,
+running the test suite, and building the docs site. Please report security issues
+privately per [SECURITY.md](SECURITY.md).
+
+## License
+
+Released under the [Apache License 2.0](LICENSE).

{kolega_code-0.26.0 → kolega_code-0.26.2}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.0"
+__version__ = "0.26.2"

{kolega_code-0.26.0 → kolega_code-0.26.2}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.0"
+__version__ = "0.26.2"

{kolega_code-0.26.0 → kolega_code-0.26.2}/kolega_code/agent/orchestration/__init__.py

@@ -19,8 +19,8 @@ from .errors import (
     WorkflowScriptError,
 )
 from .executor import DEFAULT_MAX_AGENT_DEPTH, MAX_AGENT_DEPTH, extract_meta, run_script, safe_builtins
-from .journal import RunJournal, saved_workflows_dir, workflows_root
-from .runtime import DEFAULT_AGENT_CAP, MAX_FANOUT, WorkflowRuntime, default_concurrency
+from .journal import ResumeCache, RunJournal, saved_workflows_dir, workflows_root
+from .runtime import DEFAULT_AGENT_CAP, DEFAULT_WORKFLOW_CONCURRENCY, MAX_FANOUT, WorkflowRuntime
 from .types import AgentRunResult, AgentRunSpec, DispatchFn, EmitFn
 
 __all__ = [
@@ -34,11 +34,12 @@ __all__ = [
     "safe_builtins",
     "DEFAULT_MAX_AGENT_DEPTH",
     "MAX_AGENT_DEPTH",
+    "ResumeCache",
     "RunJournal",
     "workflows_root",
     "saved_workflows_dir",
     "WorkflowRuntime",
-    "default_concurrency",
+    "DEFAULT_WORKFLOW_CONCURRENCY",
     "MAX_FANOUT",
     "DEFAULT_AGENT_CAP",
     "AgentRunSpec",

{kolega_code-0.26.0 → kolega_code-0.26.2}/kolega_code/agent/orchestration/executor.py

@@ -20,6 +20,9 @@ from typing import Any, Dict
 from .errors import WorkflowScriptError
 
 WRAPPER_NAME = "__workflow_main__"
+# Filename the script is compiled under; traceback frames with this filename
+# carry line numbers into the authored source (AST wrapping preserves them).
+SCRIPT_FILENAME = "<workflow>"
 DEFAULT_MAX_AGENT_DEPTH = 1
 MAX_AGENT_DEPTH = 2
 
@@ -173,7 +176,7 @@ async def run_script(source: str, namespace: Dict[str, Any]) -> Any:
     """
     try:
         module = _wrap_as_coroutine(source)
-        code = compile(module, "<workflow>", "exec")
+        code = compile(module, SCRIPT_FILENAME, "exec")
     except SyntaxError as exc:
         raise WorkflowScriptError(f"workflow script has a syntax error: {exc}") from exc