ness-agent 0.2.2__tar.gz → 0.2.4__tar.gz

{ness_agent-0.2.2 → ness_agent-0.2.4}/.gitignore

@@ -13,6 +13,7 @@ wheels/
 # Virtual environments
 .venv
 .env
+.env.evals
 
 # Ness Agent runtime data
 .ness/worktrees/
@@ -20,4 +21,7 @@ wheels/
 .ness/runtime/
 
 # SDK Tests
-sdk_perf/
+sdk_perf/
+
+# Harbor eval outputs
+evals/jobs/

{ness_agent-0.2.2 → ness_agent-0.2.4}/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-09-08 — Released
+
+### Added
+
+- Image-aware `read()` for vision models: PNG, JPEG, WebP, GIF, PPM, BMP, and TIFF files are normalized (EXIF orientation, 2000px long edge, PNG re-encode, 5 MB ceiling) and returned as structured text plus image blocks. Codex and OpenRouter project those tool results into the next model request; text-only sessions get a visible omission instead of a data URL. Base64 stays out of hooks, SQLite events, traces, TUI `tool_end` payloads, and token estimates. PDFs and videos remain unsupported, with a hint to render or extract frames and `read()` the resulting images.
+- Harbor eval adapters for Terminal-Bench 2.1: OpenRouter (`evals.ness_harbor_agent:NessAgent`) and ChatGPT-authenticated Codex (`evals/codex`), plus configs and a `tb_bench.py` runner for the v0.2.3 text-only Codex baseline.
+
+### Changed
+
+- Compaction can now summarize inside a long active turn. When the current continuation exceeds a retained-suffix budget (about 40% of usable context, clamped between 8k and 65k tokens), older in-turn work is summarized while a coherent recent suffix is kept verbatim, without splitting a tool-call batch from its results. Later tool loops treat the compacted-history boundary as the start of that continuation.
+
+### Fixed
+
+- Oversized active continuations now fail explicitly when no safe retained suffix can fit, instead of reaching the provider with an over-budget request. Compaction-call usage is isolated from parent-call context accounting, and image blocks receive a bounded token allowance without persisting their base64 payloads.
+
+## [0.2.3] - 2026-08-23 — Released
+
+### Added
+
+- OpenCode Go as a built-in CLI model provider, with per-model Responses, Chat Completions, and Anthropic Messages routing, live model discovery, separate API-key storage, and rolling 5-hour/weekly/monthly subscription usage in `/status`.
+- Per-session effective SDK configuration: `NessAgent.session()` now accepts main and reflection model overrides, `Session.config` / `Session.cost_tracker` expose the effective session view, and `Session.configure_models()` can rebind one live session without changing its siblings.
+- `NessAgent.configure_default_models()` for updating the model defaults inherited by sessions created in the future.
+
+### Changed
+
+- A `NessAgent` now acts as a project-scoped owner of shared services and defaults while every `Session` receives isolated mutable runtime views for options, temporary permission rules, active MCP tools, and cost totals. Thread persistence, hooks, memory, tool definitions, persistent permission rules, tracing, and pricing remain shared.
+- CLI model/provider/reasoning changes now update the selected thread and future sessions only; other live thread runtimes retain the model configuration with which they were created.
+- Cost reporting is session-first: live usage accumulates in both the session tracker and the agent's current-process aggregate, while replayed durable usage restores only the session total.
+
+### Fixed
+
+- Concurrent `/new` and `/threads` runtimes no longer overwrite one another's effective models, temporary approvals, MCP activation, per-session callbacks, cost totals, or displayed model/provider metadata.
+- Persistent permission updates are serialized and written atomically while `session` approval rules remain local to the session that created them.
+- Resume restores historical thread cost without double-counting it as new agent spend, forks exclude inherited usage from child totals, and rollback preserves already-incurred session cost.
+- The experimental ChatGPT-authenticated Codex transport now uses one stable UUID per thread for `prompt_cache_key` and the Codex Responses transport's session-routing header without sending public-API-only cache controls; cache reads and writes are reported per call, append-only prefixes can be verified through privacy-safe debug fingerprints, and backend validation errors include their response detail and request ID.
+
 ## [0.2.2] - 2026-08-15 — Released
 
 ### Added
@@ -20,7 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - The SDK `read` tool can now read absolute file paths outside the configured project root; relative paths still resolve from the project root, while write, edit, and delete paths remain project-bound.
 - The TUI footer now labels Codex plan-backed usage as `subscription` instead of displaying the misleading `$0.0000`, while retaining dollar totals for usage-based providers.
-- Codex subscription requests now retry transient SSE failures such as `server_is_overloaded`, service-unavailable, server, and rate-limit errors with bounded exponential backoff, jitter, and `Retry-After` support; non-transient stream errors still fail immediately.
+- ChatGPT-authenticated Codex transport requests now retry transient SSE failures such as `server_is_overloaded`, service-unavailable, server, and rate-limit errors with bounded exponential backoff, jitter, and `Retry-After` support; non-transient stream errors still fail immediately.
 
 ### Fixed
 
@@ -30,7 +66,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Codex subscription provider with browser and device-code authentication via `/login`, using the installed `codex` CLI app-server and isolated Ness global credentials (never reads or writes `~/.codex`).
+- Experimental Codex integration with ChatGPT browser and device-code authentication via `/login`, using the installed `codex` CLI app-server for authentication and isolated Ness global credentials (never reads or writes `~/.codex`). Model inference uses Ness's separate ChatGPT-authenticated Codex Responses transport.
 - Pluggable model provider layer (`ness_cli/provider/`) with shared registry, profile selection, and separate Codex and OpenRouter adapters/chat models.
 - Install scripts at `https://nessagent.dev/install.sh` (macOS/Linux) and `install.ps1` (Windows).
 - Persistent session names through the SDK `Session.set_name()` / `ThreadStore.set_thread_name()` APIs and the interactive `/rename <name>` command.
@@ -41,7 +77,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- `/login` is the primary provider onboarding path: choose Codex subscription or OpenRouter API key, switch active providers mid-session, and reconnect or log out from a dedicated picker.
+- `/login` is the primary provider onboarding path: sign in to Codex with ChatGPT or configure an OpenRouter API key, switch active providers mid-session, and reconnect or log out from a dedicated picker.
 - `/status` labels subscription usage as `subscription` rather than estimating it as API spend.
 - TUI pickers now expand responsively to show up to 12 choices while retaining transcript space, with improved approval and question layouts.
 - **Breaking:** the SQLite `threads` table now requires a `name` column. Automatic database migrations are intentionally unsupported; back up or remove `.ness/threads/threads.db` before using this version. Removing it permanently discards saved threads unless they were backed up externally.
@@ -87,7 +123,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - SDK: LangGraph agent loop, built-in tools, permissions, memory, skills, hooks, MCP, compaction, reflection, and tracing.
 - CLI: interactive TUI (`ness`), headless print mode (`-p`), plan/act modes, git worktrees, global config, and `.ness/` project layout.
 
-[Unreleased]: https://github.com/Sagnnik/ness-agent/compare/v0.2.2...HEAD
+[Unreleased]: https://github.com/Sagnnik/ness-agent/compare/v0.2.4...HEAD
+[0.2.4]: https://github.com/Sagnnik/ness-agent/compare/v0.2.3...v0.2.4
+[0.2.3]: https://github.com/Sagnnik/ness-agent/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/Sagnnik/ness-agent/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/Sagnnik/ness-agent/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/Sagnnik/ness-agent/compare/v0.1.0...v0.2.0

{ness_agent-0.2.2 → ness_agent-0.2.4}/CONTRIBUTING.md

@@ -44,7 +44,8 @@ PACKAGING_SMOKE=1 uv run pytest -q -m packaging
 
 ## Pull requests
 
-1. Please open an issue to propose features or major changes before submitting a PR so we can align on design early.
+1. Small PRs only — keep changes focused and minimal. Large PRs will not be accepted.
+2. Large feature requests — open an issue first to discuss the design before writing any code.
 2. Branch from `main` (e.g. `feat/cli-cron`, `fix/session-resume`).
 3. Keep changes focused; match existing code style in touched files.
 4. Ensure tests pass before opening a PR.

{ness_agent-0.2.2 → ness_agent-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ness-agent
-Version: 0.2.2
+Version: 0.2.4
 Summary: Ness Agent is an experimental, hackable agent harness.
 Project-URL: Homepage, https://github.com/Sagnnik/ness-agent
 Project-URL: Documentation, https://github.com/Sagnnik/ness-agent/tree/main/docs
@@ -61,6 +61,7 @@ Ness Agent is an experimental, hackable coding-agent harness for engineers who w
 <p align="center">
   <img src="assets/ness_agent_sc.png" alt="NessAgent terminal UI showing project context, tool execution, and Act mode" width="100%">
 </p>
+<p align="center"><a href="https://raw.githubusercontent.com/Sagnnik/ness-agent/main/assets/ness-demo6.mp4">Open the demo video</a></p>
 <p align="center"><em>NessAgent TUI in Act mode.</em></p>
 
 > **0.x experimental** — APIs may change until 1.0. See [CHANGELOG](https://github.com/Sagnnik/ness-agent/blob/main/CHANGELOG.md).
@@ -82,7 +83,6 @@ Ness Agent is an experimental, hackable coding-agent harness for engineers who w
 | **Ness Agent SDK** | LangGraph agent loop, built-in tools, permissions, memory, skills, hooks, MCP, compaction, reflection, tracing |
 | **Ness CLI** | Terminal UI (`ness`), plan/act modes, git worktrees, global config, `.ness/` project layout |
 
-Both are included in the `ness-agent` PyPI package. OpenRouter-compatible chat models, native tool-calling, cache-safe summary compaction, and filesystem-driven extension points under `.ness/`.
 
 ## Installation
 
@@ -108,10 +108,15 @@ uv tool install --upgrade ness-agent
 # or: pipx install ness-agent
 ```
 
-Launch `ness` and run `/login` to use either a Codex subscription or an
-OpenRouter API key. Codex sign-in uses the installed `codex` CLI's managed
-browser/device flow and stores credentials in Ness's isolated global config
-directory; it never reads or changes `~/.codex`.
+Launch `ness` and run `/login` to sign in to Codex with ChatGPT or configure an
+OpenRouter API key. Codex authentication uses the installed `codex` CLI
+app-server's managed browser/device flow and stores credentials in Ness's
+isolated global config directory; it never reads or changes `~/.codex`.
+
+> [!NOTE]
+> Ness's Codex model transport is experimental. Authentication and credential
+> management are handled by Codex app-server, while Ness sends inference
+> requests directly to the ChatGPT Codex Responses endpoint used by Codex CLI.
 
 For environment-based OpenRouter setup:
 

{ness_agent-0.2.2 → ness_agent-0.2.4}/README.md

@@ -14,6 +14,7 @@ Ness Agent is an experimental, hackable coding-agent harness for engineers who w
 <p align="center">
   <img src="assets/ness_agent_sc.png" alt="NessAgent terminal UI showing project context, tool execution, and Act mode" width="100%">
 </p>
+<p align="center"><a href="https://raw.githubusercontent.com/Sagnnik/ness-agent/main/assets/ness-demo6.mp4">Open the demo video</a></p>
 <p align="center"><em>NessAgent TUI in Act mode.</em></p>
 
 > **0.x experimental** — APIs may change until 1.0. See [CHANGELOG](https://github.com/Sagnnik/ness-agent/blob/main/CHANGELOG.md).
@@ -35,7 +36,6 @@ Ness Agent is an experimental, hackable coding-agent harness for engineers who w
 | **Ness Agent SDK** | LangGraph agent loop, built-in tools, permissions, memory, skills, hooks, MCP, compaction, reflection, tracing |
 | **Ness CLI** | Terminal UI (`ness`), plan/act modes, git worktrees, global config, `.ness/` project layout |
 
-Both are included in the `ness-agent` PyPI package. OpenRouter-compatible chat models, native tool-calling, cache-safe summary compaction, and filesystem-driven extension points under `.ness/`.
 
 ## Installation
 
@@ -61,10 +61,15 @@ uv tool install --upgrade ness-agent
 # or: pipx install ness-agent
 ```
 
-Launch `ness` and run `/login` to use either a Codex subscription or an
-OpenRouter API key. Codex sign-in uses the installed `codex` CLI's managed
-browser/device flow and stores credentials in Ness's isolated global config
-directory; it never reads or changes `~/.codex`.
+Launch `ness` and run `/login` to sign in to Codex with ChatGPT or configure an
+OpenRouter API key. Codex authentication uses the installed `codex` CLI
+app-server's managed browser/device flow and stores credentials in Ness's
+isolated global config directory; it never reads or changes `~/.codex`.
+
+> [!NOTE]
+> Ness's Codex model transport is experimental. Authentication and credential
+> management are handled by Codex app-server, while Ness sends inference
+> requests directly to the ChatGPT Codex Responses endpoint used by Codex CLI.
 
 For environment-based OpenRouter setup:
 

{ness_agent-0.2.2 → ness_agent-0.2.4}/docs/architecture.md

@@ -12,6 +12,20 @@ Ness Agent is split into a reusable **SDK** and a **coding CLI adapter** (Ness).
 
 See also: [SDK guide](sdk.md) · [CLI guide](cli.md) · [Configuration](configuration.md)
 
+### Runtime ownership
+
+`NessAgent` represents one project/application runtime. It owns resolved defaults and services that are safe or useful to share across that project's sessions. `NessAgent.session()` takes a selective effective-config snapshot so live threads do not mutate one another.
+
+| Scope | State |
+|------|------|
+| Agent/project | Thread persistence, memory backend, hooks, skill loader, tool definitions and MCP catalog, persistent permission file/lock, tracer, pricing, and defaults inherited by future sessions |
+| Session/thread | Effective main/reflection models and options, temporary permission rules, active MCP tools and binding cache, cost totals, graph/checkpointer, event queue, cancellation token, mode, metadata, and adapter callbacks |
+| Turn | User input, optional mode/skill overrides, usage aggregate, streamed events, and active cancellation state |
+
+Live model usage is recorded in the session tracker and propagated once to the agent aggregate. Durable replay updates only the session tracker, so resuming a thread does not look like newly incurred provider spend. Persistent permission choices are shared through `permissions.json`; temporary `session` choices stay on the session-local view. Tool definitions are shared, while deferred MCP activation is session-local.
+
+The Ness CLI keeps one `CodingSession` runtime per live thread. `/new` and `/threads` may therefore leave one turn running while another thread becomes selected. A `/config` model/provider/reasoning change rebuilds the selected runtime and updates agent defaults for future runtimes; already-live sibling threads remain pinned.
+
 ### MCP boundary
 
 The SDK's `MCPRuntime` accepts fully resolved stdio or HTTP server specifications and owns connections, session lifecycle, tool discovery, LangChain tool conversion, calls, and structured connection state. It has no project-file, terminal, trust, or credential-storage policy, so it can be embedded in domain-specific or domain-agnostic applications.
@@ -55,6 +69,13 @@ Session tool tiers (same set bound in both modes):
 - Advanced: `spawn_subagent`
 - Loaded MCP tools: any `mcp__*` tool activated this session (deferred by default; load via `search_tools`/`add_tools` or `/mcp <server> [tool]`)
 
+For vision-capable sessions, `read` accepts PNG, JPEG, WebP, GIF, PPM, BMP,
+and TIFF files and returns a normalized image block to the model. Images are
+oriented from EXIF metadata, resized to a 2000px maximum long edge, encoded as
+PNG, and rejected if the normalized payload exceeds 5 MB. Text-only sessions
+receive an explicit omission marker. PDFs and videos are not passed directly;
+render PDF pages or extract video frames to a supported raster format first.
+
 ---
 
 ## Memory
@@ -92,8 +113,8 @@ Compaction is a cache-safe fork of the main conversation. At every boundary befo
 | 70-80% | Warn that summary compaction is approaching |
 | >= 80% | Summarize completed history |
 
-Compaction also runs earlier when necessary to preserve `COMPACTION_BUFFER_TOKENS` for the instruction and capped summary output. The latest unanswered user turn and its complete assistant/tool trajectory remain verbatim; only completed history is summarized. Old L3 reminders are visible to the cache-safe fork but explicitly excluded from summary semantics. The replacement branch contains one human `<compacted-history>` message, the active suffix, and one newly rendered current L3 reminder.
+Compaction also runs earlier when necessary to preserve `COMPACTION_BUFFER_TOKENS` for the instruction and capped summary output. Normally the latest unanswered user turn and its assistant/tool trajectory remain verbatim. If that continuation itself exceeds about 40% of usable context (clamped between 8k and 65k tokens), Ness summarizes its older work and retains a coherent recent suffix without splitting a tool-call batch from its results. Old L3 reminders are visible to the cache-safe fork but explicitly excluded from summary semantics. The replacement branch contains one human `<compacted-history>` message, the retained active suffix, and one newly rendered current L3 reminder.
 
 Image-bearing user messages remain structured in live and replayed canonical history after they are answered. They are removed only when their completed turn is replaced by summary compaction (or when vision is explicitly disabled).
 
-Compaction is a separate graph node between `START`/`tools` and `agent`, so it never runs during tool execution and its state checkpoints before the next model request. Summary failures preserve the original history and may continue below the safety boundary; at the boundary the turn stops rather than using a lossy fallback. `/compact` forces this process at the next model boundary.
+Compaction is a separate graph node between `START`/`tools` and `agent`, so it never runs during tool execution and its state checkpoints before the next model request. Summary-call usage is isolated from the parent agent call so it cannot distort later context-pressure accounting. Summary failures preserve the original history and may continue below the safety boundary; at the boundary the turn stops rather than using a lossy fallback. If no safe retained suffix can fit, the turn fails explicitly instead of sending an oversized request. `/compact` forces this process at the next model boundary.

{ness_agent-0.2.2 → ness_agent-0.2.4}/docs/cli.md

@@ -1,6 +1,6 @@
 # Ness CLI
 
-**Ness** is the interactive coding-agent CLI shipped with Ness Agent. It supports Codex subscription and OpenRouter models, plan/act modes, filesystem-driven extension points under `.ness/`, and a full TUI for approvals, thread history, and configuration.
+**Ness** is the interactive coding-agent CLI shipped with Ness Agent. It supports plan/act modes, filesystem-driven extension points under `.ness/`, and a full TUI for approvals, thread history, and configuration.
 
 See also: [Configuration](configuration.md) · [Architecture](architecture.md) · [SDK](sdk.md)
 
@@ -24,8 +24,8 @@ ness
 
 `/init` creates project `.ness/` (dirs, permissions, hooks, mcp, default agent profiles, empty `NESS.md`) and ensures global config (`USER.md`, `instructions/`, `plans/<slug>/`).
 
-Or skip the env var and run `/login`. Choose Codex subscription for managed
-browser/device authentication, or OpenRouter for a masked API-key prompt. Device-code
+Or skip the env var and run `/login`. Choose Codex to sign in with ChatGPT
+using managed browser/device authentication, or OpenRouter/OpenCode Go for a masked API-key prompt. Device-code
 login must first be enabled in ChatGPT **Settings > Security** by turning on
 **Device code authorization for Codex**; browser login does not require that setting.
 Selecting a connected provider makes it active and exposes only **Reconnect** and
@@ -246,19 +246,19 @@ Shift+Tab toggles plan/act mode without rebuilding the graph or invalidating the
 
 - `/help`: show the command reference.
 - `/login`: authenticate or manage model providers in a dedicated picker. Selecting a connected provider activates it and offers Reconnect/Log out; selecting a disconnected provider starts authentication immediately. Provider changes rebuild the model while preserving the thread.
-- `/config`: edit provider keys/endpoints, model/reasoning, behavior toggles, compaction budgets, and advanced options (persisted to global `configs.json` / `secrets.json`).
+- `/config`: edit provider keys/endpoints, model/reasoning, behavior toggles, compaction budgets, and advanced options (persisted to global `configs.json` / `secrets.json`). Model/provider/reasoning changes rebuild the selected thread and become defaults for future threads; other live thread runtimes keep their existing model configuration.
 - `/exit` or `/quit`: end the session.
 
 **Session**
 
-- `/status`: show provider authentication, account email/tier, every available usage-limit window (including weekly), reset times/credits, and session token/cache/cost stats. Subscription calls are labeled `subscription` rather than estimated as API spend.
+- `/status`: show provider authentication, account email/tier, every available usage-limit window (including OpenCode Go's rolling 5-hour, weekly, and monthly windows), reset times/credits, and the selected session's token/cache/cost stats. Subscription calls are labeled `subscription` rather than estimated as API spend.
 - `/threads`: open a scrollable saved-thread picker, ordered by recent updates and prefixed with local `YYYY-MM-DD HH:mm` timestamps. Threads with active turns show an animated working indicator; switching away does not interrupt them.
 - `/rename <name>`: set or update the current session's persistent display name (1–80 characters; requires thread autosave).
 - `/fork`: choose a human message, copy the conversation state before it into a child thread, and prefill that message for editing. Forking copies session memory/checkpoints but leaves current working-tree files unchanged.
 - `/goal <objective>`: run up to three worker attempts, each followed by an isolated read-only judge. Failed verdicts become repair instructions for the next attempt.
 - `/save`: archive the current thread with a headline summary.
 - `/new`: archive and start a fresh thread. During an active turn, the running thread stays in the background and the new thread starts independently.
-- `/compact`: request a cache-safe summary at the next model boundary; the active user/tool turn remains verbatim.
+- `/compact`: request a cache-safe summary at the next model boundary; the active user/tool turn remains verbatim unless it exceeds the retained-suffix budget, in which case older in-turn work is summarized and a coherent recent suffix is kept.
 - `/reflection`: immediately reflect on conversation messages added since the last successful reflection and update session memory.
 - `/export <path.html>`: write the current durable session as a self-contained, interactive HTML transcript. The export retains events from before compactions, includes an in-page normalized JSONL download, omits pasted image bytes, and refuses to overwrite an existing file. Quote paths that contain spaces.
 
@@ -310,7 +310,7 @@ Event kinds stored in `events.payload` (session threads only):
 
 `/threads` lists user `session-*` threads only. Each row starts with its locally converted update datetime and uses an explicit `/rename` name when present, then falls back to the archived summary or first user message. The original conversation shows `×N` when it has forks; each fork shows `fork #k` in creation order. Fork lineage is stored explicitly on the thread row; inherited usage remains in the copied event history but is excluded from the child thread's cost totals. Subagent trajectories are not stored in `events`; subagent LLM usage rolls up into the parent session's `threads` aggregates. Subagent outputs are stored in the `subagents` table.
 
-Selecting a thread rebuilds user messages, assistant tool-call turns, and tool results from saved events. The startup `--resume <thread_id>` flag remains available for automation. `spawn_subagent` tool output is supplemented from linked subagent outputs when available.
+Selecting an idle saved thread rebuilds user messages, assistant tool-call turns, and tool results from saved events. A thread that is already live keeps its own model, temporary approvals, MCP activation, graph, cancellation state, and cost total when selected again. The startup `--resume <thread_id>` flag remains available for automation. `spawn_subagent` tool output is supplemented from linked subagent outputs when available.
 
 When a thread contains a successful new-format `compaction_llm` checkpoint, resume starts from its summary and replays only raw events after `source_event_seq`. Raw conversation events remain available for audit, rollback, and forks; L3 reminder messages are never written to the event log.
 

{ness_agent-0.2.2 → ness_agent-0.2.4}/docs/configuration.md

@@ -68,9 +68,10 @@ Project `.env` files are not loaded or migrated for Ness application settings. E
 Use `/login` to authenticate, activate, reconnect, or log out of a model provider.
 Selecting a connected provider activates it and opens its Reconnect/Log out menu;
 selecting a disconnected provider starts authentication without an extra Connect step.
-OpenRouter keys are stored in `secrets.json`. Codex subscription credentials
-are managed by the system `codex` CLI under `<NESS_AGENT_CONFIG_DIR>/codex/`
-with file credential storage forced; Ness does not reuse `~/.codex`.
+OpenRouter and OpenCode Go keys are stored separately in `secrets.json`. ChatGPT credentials for Codex
+are managed by the system `codex` CLI app-server under
+`<NESS_AGENT_CONFIG_DIR>/codex/` with file credential storage forced; Ness
+does not reuse `~/.codex`.
 Codex device-code login additionally requires **Device code authorization for
 Codex** to be enabled in ChatGPT **Settings > Security**. Use browser login if
 that account setting is unavailable.
@@ -79,6 +80,12 @@ Provider-specific model and reasoning choices are nested under
 `provider_profiles` in `configs.json`, so switching providers restores each
 provider's last selection. Legacy top-level OpenRouter settings remain valid.
 
+In the concurrent TUI, saved configuration is the default for new thread
+runtimes. Changing the model, provider, or reasoning effort through `/config`
+also rebuilds the currently selected thread, but it does not mutate sibling
+threads that are already live. Selecting one of those threads later restores
+its pinned runtime configuration.
+
 ---
 
 ## Environment variables
@@ -87,8 +94,8 @@ All except `NESS_DIR` are also editable via `/config` in the Ness TUI.
 
 | Variable | Description |
 |----------|-------------|
-| `MODEL_PROVIDER` | Active provider (`openrouter` by default, or `codex`) |
-| `MODEL_NAME` | Model passed to `ChatOpenRouter` (`deepseek/deepseek-v4-flash` by default) |
+| `MODEL_PROVIDER` | Active provider (`openrouter` by default, `codex`, or `opencode`) |
+| `MODEL_NAME` | Active provider model ID (`deepseek/deepseek-v4-flash` by default) |
 | `REFLECTION_MODEL_NAME` | Model for background session-memory reflection (defaults to `MODEL_NAME`) |
 | `ENABLE_APPROVAL` | Require approval for destructive tools |
 | `AUTO_SAVE_THREADS` | Write thread events to `.ness/threads/` |
@@ -105,6 +112,7 @@ All except `NESS_DIR` are also editable via `/config` in the Ness TUI.
 | `GOAL_MAX_ATTEMPTS` | Maximum worker/judge attempts for `/goal` (default `3`) |
 | `OPENAI_BASE_URL` | Optional custom OpenAI-compatible base URL |
 | `OPENAI_API_KEY` | Provider API key (also stored in `secrets.json` via `/config`) |
+| `OPENCODE_GO_API_KEY` / `OPENCODE_API_KEY` | OpenCode Go subscription key (also stored separately in `secrets.json`) |
 | `FORMAT_ON_WRITE` | Auto-format supported file types after writes (default `true`) |
 | `NESS_DIR` | Project config directory (default `.ness`) |
 | `NESS_AGENT_CONFIG_DIR` | Override global config root |
@@ -123,9 +131,4 @@ advanced options; provider-only fields are hidden when they do not apply.
 
 The `/config` model picker reads the active provider's catalog. OpenRouter's
 global disk cache is reused for 24 hours with a packaged offline fallback;
-Codex models are supplied by `codex app-server` for the signed-in account.
-
-Codex access tokens are refreshed through `account/read` shortly before JWT
-expiry and once after an HTTP 401. Network, rate-limit, and server failures do
-not trigger credential refresh. The subscription Responses transport is kept
-inside `src/ness_cli/provider/codex/` because that endpoint is experimental.
+`codex app-server` handles ChatGPT authentication and credential management for the signed-in account. Ness performs model inference separately through its experimental ChatGPT-authenticated Codex Responses transport.

{ness_agent-0.2.2 → ness_agent-0.2.4}/docs/sdk-api.md

@@ -1,6 +1,6 @@
 # SDK API reference
 
-This reference covers the symbols exported by `ness_agent.__all__` in the 0.2.2 source tree. It is intentionally an API map rather than a second tutorial: start with the [SDK guide](sdk.md) for the shortest working example, then use this page when choosing a seam to own.
+This reference covers the symbols exported by `ness_agent.__all__` in the 0.2.4 source tree. It is intentionally an API map rather than a second tutorial: start with the [SDK guide](sdk.md) for the shortest working example, then use this page when choosing a seam to own.
 
 > **0.x experimental.** Names and signatures below describe the current public surface; pin a version before relying on it in production.
 
@@ -15,13 +15,18 @@ agent.session(*, thread_id: str, mode: str | None = None,
               metadata: Mapping[str, Any] | None = None,
               git_available: bool | None = None, vision: bool | None = None,
               on_plan_turn: PlanTurnHandler | None = None,
-              on_interrupt: InterruptHandler | None = None) -> Session
+              on_interrupt: InterruptHandler | None = None,
+              model: BaseChatModel | None = None,
+              reflection_model: BaseChatModel | None | object = _UNSET) -> Session
+agent.configure_default_models(*, model: BaseChatModel,
+                               reflection_model: BaseChatModel | None,
+                               context_window: int | None) -> None
 agent.new_thread_id(prefix: str = "session") -> str
 ```
 
-The top-level SDK entry point owns a resolved shared configuration and creates an isolated `Session` per conversation thread. `model` is a LangChain `BaseChatModel`; `prompt` accepts `PromptLayers`, `PromptLayersConfig`, or a mapping. With `tools=None`, the SDK resolves its built-in tool set. `config` exposes the resolved `NessAgentConfig` when an application needs to inspect the constructed backends.
+The top-level SDK entry point owns project services and resolved defaults, then creates an isolated effective configuration for each `Session`. `model` is a LangChain `BaseChatModel`; `prompt` accepts `PromptLayers`, `PromptLayersConfig`, or a mapping. With `tools=None`, the SDK resolves its built-in tool set. `agent.config` exposes project defaults and the live aggregate cost tracker; `session.config` exposes the effective session fork.
 
-`session()` accepts optional per-thread metadata for the L3 overlay. `vision=True` sends supplied image URLs; `False` drops them to text and emits a warning event; `None` leaves content shape untouched. The two callback hooks live on a session, not on the shared agent, so concurrent threads do not overwrite each other.
+`session()` accepts optional per-thread metadata for the L3 overlay and effective main/reflection model overrides. `vision=True` sends supplied image URLs; `False` drops them to text and emits a warning event; `None` leaves content shape untouched. The two callback hooks live on a session, not on the shared agent, so concurrent threads do not overwrite each other. `configure_default_models()` changes inheritance for sessions created later; it does not rebuild existing sessions.
 
 ```python
 agent = NessAgent(model=model, prompt=PromptLayersConfig())
@@ -74,10 +79,19 @@ await session.run(message: str, *, images: Sequence[str] | None = None,
 
 async for event in session.stream(message: str, *, images=None,
                                   active_skills=None, mode=None): ...
+
+session.config -> NessAgentConfig
+session.cost_tracker -> CostTracker
+session.configure_models(*, model: BaseChatModel,
+                         reflection_model: BaseChatModel | None,
+                         context_window: int | None,
+                         vision: bool | None) -> None
 ```
 
 `run()` collects one complete turn. It returns assistant text, an aggregate `usage_total` over every model call in the turn, the current todos, and every intermediate event. `stream()` yields those `SessionEvent` records as the graph advances. `mode=` is a one-turn override; otherwise the session’s current `act` or `plan` mode is used.
 
+Each session owns a selective shallow fork of the agent configuration. Mutable runtime state—models and options, temporary permission rules, active MCP tools, and cost totals—is isolated. Project services such as thread persistence, hooks, memory, and the underlying permission/tool catalogs remain shared. `session.config` exposes the effective session view; `agent.config` remains the defaults inherited by future sessions plus the live agent-level cost aggregate.
+
 Important control and inspection methods:
 
 | Method | Purpose |
@@ -87,6 +101,7 @@ Important control and inspection methods:
 | `bootstrap(messages)` | Seed prior messages into the next turn once; use for resume or rollback replay. |
 | `cancel()` / `is_cancelled()` | Request and inspect cooperative cancellation of the active stream. |
 | `request_compact()` | Request compaction on the next turn. |
+| `configure_models(...)` | Replace this session's effective main/reflection models and context settings, then rebuild its graph. |
 | `active_skills(names)` / `stage_skills(names)` | Replace or append one-shot skills for the next turn. |
 | `get_state()`, `get_messages()`, `get_todos()` | Async snapshots of the checkpointed state. |
 | `preview_context(mode=None) -> ContextPreview` | Assemble L0–L3 for debugging without running the model. |
@@ -175,23 +190,29 @@ Sources: `src/ness_agent/context/overlay.py`, `context/coding_overlay.py`, and `
 
 ```python
 ToolRegistry(tools: Iterable[BaseTool] | None = None, *, include: Iterable[str] | None = None)
+registry.fork_for_session() -> ToolRegistry
 coding_tools(*, include: list[str] | None = None) -> ToolRegistry
 ```
 
 The registry owns known tools and the currently bound active set. Core reads are `active_tools`, `tool_map()`, `tool_names()`, `all_tools()`, and `deferred_tool_names()`. Call `bind_model(model)` to return a tool-bound chat model, and `sync()` after a structural change. `register_dynamic(tools)` adds dynamic tools as known but inactive; `activate_mcp(names)` and `deactivate_mcp(names)` return `(changed, unknown)` lists and adjust the active MCP set.
 
+`fork_for_session()` creates a registry view that shares tool definitions and the deferred MCP catalog while keeping its active MCP names, include filter, binding cache, and local generation independent. Structural catalog additions remain visible to all session views; activating a deferred MCP tool affects only that session.
+
 `set_mcp_catalog()` and `deferred_mcp_summary()` maintain the lightweight deferred-MCP prompt catalog. `is_destructive(name, args)` and `is_read_only(name, args)` expose the registry’s policy classification. `coding_tools()` is the small convenience factory for name-selected SDK tools.
 
-The default tool list includes file read/write/delete/edit/glob, search, web fetch/search, shell, todos, tool discovery, subagents, questions, and skill viewing. It is not an API guarantee for every named tool; configure an explicit tool sequence when a host application needs a narrower contract.
+The default tool list includes file read/write/delete/edit/glob, search, web fetch/search, shell, todos, tool discovery, subagents, questions, and skill viewing. In vision-capable sessions, `read` normalizes supported raster files and returns structured image content; PDFs and videos must first be rendered or split into raster frames. Image payloads are redacted from durable and display-facing events. This is not an API guarantee for every named tool; configure an explicit tool sequence when a host application needs a narrower contract.
 
 ### `PermissionStore`
 
 ```python
 PermissionStore(*, ness_dir: Path = Path(".ness"), project_root: Path | None = None)
+store.fork_for_session() -> PermissionStore
 ```
 
 The file-backed policy store validates paths under the project root and resolves tool calls to `allow`, `deny`, or `ask` decisions. The main public operations are `check(tool, args)`, `check_with_rule(tool, args)`, `pattern_key(tool, args)`, `default_rule_for(tool, args)`, `persist_rule(...)`, `remove_rule(bucket, index)`, `list_rules()`, and `clear_session_rules()`. Use it when embedding an operator-approved policy rather than bypassing the tool executor.
 
+`fork_for_session()` shares the persistent `permissions.json` path and synchronization lock while copying temporary allow/deny rules. A `session` decision therefore affects one session; `always`/`never` decisions are atomically persisted and become visible to every session on the project.
+
 ### `Hook` and `HookRunner`
 
 ```python
@@ -296,11 +317,15 @@ Sources: `src/ness_agent/memory.py` and `persistence.py`.
 PricingDict = dict[str, tuple[float, float, float]]
 CostTracker(pricing: PricingDict | None = None,
             estimate_cost: Callable[[str, int, int, int], float | None] | None = None)
+tracker.fork_for_session() -> CostTracker
 tracker.add(usage, model_name=None, response_metadata=None) -> TokenUsage | None
+tracker.restore(usage, model_name=None, response_metadata=None) -> TokenUsage | None
 ```
 
 `TokenUsage` is a slots dataclass with model, input/uncached/cached/output/total tokens, `cost_usd`, `cost_source`, cache-hit rate, and calls. `as_dict()` serializes it. `CostTracker.add()` ingests provider usage and prefers provider-reported cost, then a supplied estimator, then a matching substring key in `pricing`. Pricing triples are USD per million tokens: `(input, output, cache_read_ratio)`.
 
+`CostTracker.fork_for_session()` returns an empty tracker with shared pricing. New usage also rolls into the parent tracker; `restore()` loads durable historical usage locally without changing that live aggregate. Read per-thread totals from `session.cost_tracker` and current-process agent totals from `agent.config.cost_tracker`.
+
 Use `for_model(model)`, `total()`, `models()`, or the scalar aggregate properties (`input_tokens`, `output_tokens`, `total_tokens`, `calls`, `cost_usd`, `cache_hit_rate`, `total_cost_usd`) to inspect accumulated data. `report()` returns a text report.
 
 ### `TracingConfig`, `Tracer`, `Span`, and implementations

{ness_agent-0.2.2 → ness_agent-0.2.4}/docs/sdk.md

@@ -56,6 +56,48 @@ asyncio.run(main())
 
 `tools=` accepts a mix of `BaseTool` instances, plain callables (auto-wrapped), and built-in name strings (`"read"`, `"grep"`, `"shell"`, …). Pass `overlay=NoOverlay()` to drop L3 entirely. Instruction bodies are importable — e.g. `from ness_agent.instructions import L0_HARNESS, PLAN_MODE`.
 
+In a vision-capable session, the built-in `read` tool returns supported raster
+images (PNG, JPEG, WebP, GIF, PPM, BMP, and TIFF) as structured image content.
+It applies EXIF orientation, limits the long edge to 2000px, re-encodes to PNG,
+and enforces a 5 MB normalized-payload ceiling. With `vision=False`, the model
+receives a visible omission marker instead. PDFs and videos must first be
+rendered or have frames extracted to a supported raster format. Persisted
+events, hooks, traces, and display events receive a redacted text form rather
+than the base64 image payload.
+
+### Project agents and concurrent sessions
+
+A `NessAgent` is a project-scoped runtime: it owns shared persistence, memory, hooks, skill and tool catalogs, tracing, pricing, and defaults. Each call to `agent.session(...)` creates a separate effective runtime with its own graph/checkpointer, model fields, copied options, temporary permission rules, active MCP set, cancellation state, and cost tracker.
+
+```python
+agent = NessAgent(model=default_model, prompt=PromptLayersConfig())
+
+first = agent.session(thread_id="thread-a")
+second = agent.session(thread_id="thread-b", model=specialized_model)
+
+await asyncio.gather(
+    first.run("inspect the API"),
+    second.run("inspect the database"),
+)
+```
+
+Use a different `Session` for each concurrent thread; two simultaneous `run()`/`stream()` calls on the same `Session` are unsupported. Use a different `NessAgent` for an unrelated project because project paths and shared stores belong to the agent.
+
+Changing defaults affects future sessions only:
+
+```python
+agent.configure_default_models(
+    model=new_default,
+    reflection_model=new_reflection_default,
+    context_window=200_000,
+)
+
+# Existing sessions remain pinned. This session inherits the new defaults.
+third = agent.session(thread_id="thread-c")
+```
+
+To deliberately change one live session, call `session.configure_models(...)`. Read thread usage from `session.cost_tracker`; `agent.config.cost_tracker` is the live current-process aggregate across sessions. Replayed history is restored into the session tracker without being counted as new aggregate spend.
+
 ### What the host owns
 
 Bare `Session.run` is the turn engine only. Your application still needs to:

ness_agent-0.2.4/evals/README.md

@@ -0,0 +1,68 @@
+# Harbor evals
+
+The default adapter runs Ness through OpenRouter. The `evals/codex` adapter runs
+the same Ness SDK through the ChatGPT-authenticated Codex Responses transport.
+
+Install the eval dependencies:
+
+```bash
+uv sync --group evals
+```
+
+Run one selected Terminal-Bench 2.1 task on Modal:
+
+```bash
+PYTHONPATH=. uv run --group evals harbor run \
+  -d terminal-bench/terminal-bench-2-1 \
+  --include-task-name terminal-bench/headless-terminal \
+  --agent evals.ness_harbor_agent:NessAgent \
+  --model openrouter/deepseek/deepseek-v4-flash \
+  --env modal \
+  --env-file .env \
+  --jobs-dir evals/jobs \
+  --n-concurrent 3 \
+  --n-attempts 3
+```
+
+Use another `--include-task-name` value to select a different task. Repeat the
+flag to run several named tasks in one job. `--n-concurrent` is the number of concurrent sandboxes while
+`--n-attempts` is the number of attempts on the same task. Rewards are averaged by the number of attempts.
+
+Or run it with the config file:
+```bash
+PYTHONPATH=. uv run --group evals harbor run \
+    -c evals/configs/tb-single-task.yaml \
+    --env-file .env
+```
+
+To run the Ness SDK through the ChatGPT-authenticated Codex model, use the
+separate Codex config. `CODEX_AUTH_JSON=true` makes the adapter read
+`~/.codex/auth.json` on the host, upload it only for the agent phase, and remove
+the temporary copy when the trial ends:
+
+```bash
+CODEX_AUTH_JSON=true \
+PYTHONPATH=. uv run --group evals harbor run \
+    -c evals/configs/tb-single-task-codex.yaml \
+    --env-file .env
+```
+The auth file is not committed and must not be placed under `evals/jobs`.
+
+Codex subscription runs attach an API-equivalent cost estimate to each usage
+event. The standard short-context rates (USD per 1M tokens) are:
+
+| Model | Input | Cached input | Output | Cache write |
+| --- | ---: | ---: | ---: | ---: |
+| `gpt-5.6-sol` | $4.00 | $0.40 | $20.00 | $5.00 |
+| `gpt-5.6-terra` | $2.00 | $0.20 | $12.00 | $2.50 |
+| `gpt-5.6-luna` | $0.20 | $0.02 | $1.20 | $0.25 |
+
+These mirror the [OpenAI API pricing schedule](https://developers.openai.com/api/docs/pricing)
+for estimation only; they are not ChatGPT subscription charges. Prompts over
+272K input tokens use the long-context multipliers from that schedule.
+
+If you want to view the jobs info:
+```bash
+harbor view jobs
+```
+and visit `localhost:8080`