pi-chalin 0.1.0

package/README.md

@@ -0,0 +1,264 @@
+<p align="center">
+  <a href="package.json"><img alt="version" src="https://img.shields.io/badge/version-0.1.0-111111?style=for-the-badge"></a>
+  <a href="package.json"><img alt="license" src="https://img.shields.io/badge/license-MIT-0f766e?style=for-the-badge"></a>
+  <a href="package.json"><img alt="bun" src="https://img.shields.io/badge/bun-%3E%3D1.3.14-111111?style=for-the-badge&logo=bun&logoColor=white"></a>
+  <a href="package.json"><img alt="typescript" src="https://img.shields.io/badge/typescript-6.0-3178c6?style=for-the-badge&logo=typescript&logoColor=white"></a>
+  <a href="package.json"><img alt="status" src="https://img.shields.io/badge/status-MVP-2563eb?style=for-the-badge"></a>
+</p>
+
+<h1 align="center">pi-chalin</h1>
+
+<p align="center">
+  A Pi Coding Agent extension for routed, memory-aware subagent workflows.
+</p>
+
+<p align="center">
+  <a href="#what-it-does">What It Does</a> ·
+  <a href="#quick-start">Quick Start</a> ·
+  <a href="#commands">Commands</a> ·
+  <a href="#architecture">Architecture</a> ·
+  <a href="#development">Development</a>
+</p>
+
+---
+
+## What It Does
+
+`pi-chalin` adds a coordination layer to Pi Coding Agent. It keeps simple prompts direct, but routes broad, risky, or memory-sensitive work through focused subagents when that extra structure improves the result.
+
+Use it when a task benefits from:
+
+- deeper repository discovery before implementation;
+- isolated planning, execution, and review roles;
+- resumable long-running work;
+- local memory with explicit review;
+- visible routing, safety, and runtime state in the Pi TUI;
+- audited web context for current external information.
+
+## Capabilities
+
+| Area | What pi-chalin provides |
+| --- | --- |
+| Routing | Direct execution for bounded work, chalin workflows for broad or risky work. |
+| Subagents | Built-in `scout`, `planner`, `worker`, `reviewer`, `researcher`, `delegate`, `oracle`, `context-builder`, and `conflict-resolver` agents. |
+| Topologies | `single`, `chain`, `parallel`, `dag`, and `memory-only` workflow shapes. |
+| Memory | Local records, candidates, approval/rejection, deduplication, revisions, and FTS-backed search. |
+| Artifacts | Resumable checkpoints, validation contracts, interviews, and handoffs. |
+| Safety | Approval thresholds, autonomy modes, recursion guards, single-writer isolation, stale-run recovery, and mutation checks. |
+| TUI | Smart Panel, agent manager, activity monitor, memory review, artifact panel, and web fetch audit. |
+| Evaluation | Orchestration, memory, trace, trajectory, mutation, and workflow quality evaluators. |
+
+## Current Status
+
+This is an MVP package, but it is not a sketch. The repository includes the extension entrypoint, command registration, tool registration, routing kernel, agent catalog, memory store, artifact support, web fetch support, worktree isolation, runtime guards, evaluators, and tests for the main behaviors.
+
+The README is the canonical project overview in this repository. Historical design docs are not currently checked into the tree, so the documentation below sticks to the code and files that actually exist.
+
+## Quick Start
+
+### Requirements
+
+- Bun `>=1.3.14`
+- Pi Coding Agent runtime
+
+### Install
+
+```bash
+bun add pi-chalin
+```
+
+For local development in this repository, run `bun install`.
+
+### Verify
+
+```bash
+bun run typecheck
+bun run test
+```
+
+### Load In Pi
+
+`pi-chalin` is exposed as a Pi extension through `package.json`:
+
+```json
+{
+  "pi": {
+    "extensions": ["./src/index.ts"]
+  }
+}
+```
+
+Once Pi loads the package, use `/chalin` inside a Pi session.
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `/chalin` | Open the Smart Panel. |
+| `/chalin on` | Enable autonomous routing for the current project. |
+| `/chalin off` | Disable autonomous routing for the current project. |
+| `/chalin agents` | Open the agent manager. |
+| `/chalin memory` | Review memory records and pending candidates. |
+| `/chalin memory <query>` | Search local memory. |
+| `/chalin artifacts` | Open artifact and resumable task context. |
+| `/chalin artifacts <feature>` | Resume context for a specific feature artifact. |
+| `/chalin activity` | Inspect the active or latest run. |
+| `/chalin web` | Open the web fetch audit panel. |
+| `/chalin status` | Print routing, autonomy, safety, agent, memory, and guard status. |
+
+## Tools
+
+The extension registers tools that the primary Pi agent can call when a prompt needs orchestration instead of direct execution.
+
+| Tool | Purpose |
+| --- | --- |
+| `chalin_route` | Run a selected workflow with concrete agents, topology, risk, memory, and artifact needs. |
+| `chalin_interview` | Ask blocking clarification questions before planning or running agents. |
+| `chalin_web_search` | Search or fetch web context through the audited web layer. |
+| `chalin_memory_search` | Retrieve compact durable memory during direct or routed work. |
+| `chalin_memory_write` | Save durable project or user knowledge through WriteGuard. |
+| `chalin_memory_revise` | Correct stale or inaccurate memory with evidence. |
+| `chalin_artifact_resume` | Load resumable task context from stored artifacts. |
+| `chalin_resume` | Resume the latest paused or stale chalin run. |
+
+Child agents also receive guarded internal tools, such as `chalin_project_discovery`, `chalin_project_snapshot`, `chalin_artifact_write`, `chalin_memory_search`, `chalin_memory_write`, `chalin_memory_revise`, and `chalin_web_search`, according to their capabilities and budget.
+
+## Architecture
+
+`pi-chalin` is intentionally a modular monolith. That is the right foundation here: clear module boundaries without premature service boundaries.
+
+```txt
+Package
+  assets/                 banner and packaged image assets
+  agents/                 built-in agent definitions
+  src/                    extension source
+  test/                   Bun test coverage
+  evals/                  quality and behavior evaluators
+```
+
+The npm package ships only runtime extension source, built-in agents, and this README. Tests, evaluators, and local assets stay in the repository to keep installation small.
+
+Core modules:
+
+```txt
+src/index.ts              extension registration
+src/commands.ts           /chalin command tree
+src/tools.ts              Pi tool definitions
+src/autoroute.ts          prompt-time routing nudges
+src/kernel.ts             route validation and orchestration
+src/runner.ts             mock and SDK-backed worker execution
+src/agents.ts             built-in, project, and user agent catalog
+src/config.ts             config, autonomy, safety, and overrides
+src/memory.ts             memory records, candidates, and search
+src/artifacts.ts          resumable task state and handoffs
+src/webfetch.ts           audited external context
+src/worktrees.ts          isolated writer worktrees
+src/ui.ts                 TUI surfaces and notifications
+src/schemas.ts            shared route, run, agent, and memory types
+```
+
+Runtime flow:
+
+```txt
+Prompt
+  -> Pi primary agent
+  -> direct answer, chalin_interview, chalin_resume, or chalin_route
+  -> ChalinKernel
+  -> config and safety checks
+  -> memory and artifact context
+  -> agent resolution
+  -> worker runner
+  -> output parsing
+  -> artifact and memory capture
+  -> TUI status and final response
+```
+
+## Agent Model
+
+Agents are Markdown files with YAML frontmatter. They can come from three scopes:
+
+```txt
+agents/*.md              built-in package agents
+.pi-chalin/agents/*.md   project agents
+~/.pi/chalin/agents/*.md   user agents
+```
+
+Resolution order:
+
+```txt
+name             -> project/name, then user/name, then built-in/name
+project/name     -> project only
+user/name        -> user only
+built-in/name    -> built-in only
+```
+
+Project agents win locally, user agents remain portable across projects, and built-ins provide the default catalog.
+
+## Runtime Storage
+
+Project-local runtime files live under `.pi-chalin/`:
+
+```txt
+.pi-chalin/config.json
+.pi-chalin/agents/
+.pi-chalin/artifacts/
+.pi-chalin/cache/
+.pi-chalin/memory.sqlite
+.pi-chalin/runs/
+```
+
+User-level configuration and agents currently live under `~/.pi/chalin/`. That path is part of the Pi chalin workflow namespace, not the package name.
+
+## Environment Variables
+
+Common runtime and evaluation switches use the `PI_CHALIN_` prefix:
+
+```txt
+PI_CHALIN_DISABLED
+PI_CHALIN_CHILD
+PI_CHALIN_RUNNER
+PI_CHALIN_MOCK_STEP_DELAY_MS
+PI_CHALIN_WORKFLOW_MODEL
+PI_CHALIN_WORKFLOW_THINKING
+PI_CHALIN_WORKFLOW_GATES
+```
+
+See `package.json` and the evaluator files under `evals/` for the full set used by development scripts.
+
+## Development
+
+Useful scripts:
+
+```bash
+bun run test
+bun run typecheck
+bun run eval
+bun run eval:all
+bun run eval:workflow
+bun run eval:workflow:matrix
+```
+
+The fast confidence path is:
+
+```bash
+bun run typecheck
+bun run test
+```
+
+The broader evaluator path is intentionally heavier. Use it when changing routing, runtime policy, child-tool budgets, memory behavior, or workflow scoring.
+
+The test script runs Bun's test runner directly, so `bun test` and `bun run test` exercise the same suite.
+
+## Design Principles
+
+- Route only when routing helps.
+- Keep the human in command.
+- Make autonomy observable.
+- Prefer local memory with review.
+- Treat safety gates as product behavior, not plumbing.
+- Keep the architecture modular before splitting boundaries.
+- Verify with tests and evaluators, not intuition.
+
+## License
+
+MIT. See [`package.json`](package.json) for the current package metadata.

package/agents/conflict-resolver.md

@@ -0,0 +1,28 @@
+---
+name: conflict-resolver
+description: Resolves isolated worktree merge conflicts with surgical edits.
+concern: conflict-resolution
+capabilities: inspect-files, search-files, run-safe-bash, validate, edit-files, memory-read, memory-write
+model: inherit
+thinking: high
+tools: read, grep, find, ls, bash, edit
+memory-read: true
+memory-write: candidate
+memory-categories: bugfix, implementation, conflict-resolution
+---
+You are the pi-chalin conflict-resolver. Resolve only merge conflicts produced by isolated writer worktrees.
+
+Rules:
+- Treat the primary worktree as source of truth plus the isolated patch intent supplied in the task.
+- Use targeted edits only. Do not rewrite whole files.
+- Do not invent broader fixes; reconcile only the conflicting change.
+- If conflict intent is unclear or unsafe, stop and report exactly what human decision is needed.
+- Run the nearest safe validation command only when it is obvious and cheap.
+
+Tool discipline:
+- Prefer read/grep/find/ls/edit.
+- Bash is only for safe git status/diff/show and validation commands.
+- Never create scripts or modify files through bash.
+
+Stop condition:
+- Stop once the conflicting intent has been surgically applied or you have reported why it cannot be safely resolved.

package/agents/context-builder.md

@@ -0,0 +1,31 @@
+---
+name: context-builder
+description: Packages repo and research findings into focused implementation context.
+concern: context-building
+capabilities: inspect-files, search-files, memory-read, memory-write, external-context
+model: inherit
+thinking: medium
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: context, handoff
+---
+You are the pi-chalin context-builder. Convert verified findings into a bounded context bundle for planners, workers, or reviewers.
+
+Rules:
+- Do not edit product code.
+- Avoid open-ended research unless the router authorized it.
+- Output assumptions, constraints, relevant files, and a clear handoff.
+- For deep project analysis, preserve a Coverage Matrix and Evidence Table; do not compress away domain-critical modules, tools, routes, sync, integrations, tests, or gaps.
+- Do not merge claims into the handoff unless they have evidence or are explicitly labeled as inference.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when the next agent has enough facts, constraints, relevant paths, and uncertainties to act without re-scanning.
+- For deep project analysis, stop only after the handoff names covered, not-present, and unknown/gap surfaces with evidence.

package/agents/delegate.md

@@ -0,0 +1,28 @@
+---
+name: delegate
+description: Generic fallback delegate when no specialized responsibility fits.
+concern: delegation
+capabilities: inspect-files, search-files, memory-read, coordinate
+model: inherit
+thinking: low
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: delegation
+---
+You are the pi-chalin delegate. Handle narrow tasks that do not justify a specialized agent.
+
+Rules:
+- Stay inside the task boundaries.
+- Prefer read-only work unless the router explicitly grants write permissions.
+- Escalate ambiguity instead of inventing scope.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when the bounded task is complete or ambiguity requires escalation.

package/agents/oracle.md

@@ -0,0 +1,28 @@
+---
+name: oracle
+description: Decision consistency agent for detecting drift and contradictions.
+concern: decision-consistency
+capabilities: inspect-files, search-files, memory-read, coordinate
+model: inherit
+thinking: high
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: decision, architecture
+---
+You are the pi-chalin oracle. Protect long-running work from drift.
+
+Rules:
+- Compare current direction against accepted decisions, docs, and constraints.
+- Do not edit files.
+- Return contradictions, confidence, and the safest next decision.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when contradictions, confidence, and safest next decision are clear.

package/agents/planner.md

@@ -0,0 +1,28 @@
+---
+name: planner
+description: Turns context into an implementation plan with risks and validation.
+concern: planning
+capabilities: inspect-files, search-files, memory-read, coordinate
+model: inherit
+thinking: high
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: decision, plan
+---
+You are the pi-chalin planner. Produce plans that can be executed safely by a worker.
+
+Rules:
+- Do not edit product code.
+- Separate facts from assumptions.
+- Include files likely to change, risks, rollback notes, and verification steps.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when the plan has ordered phases, likely files, validation, risks, and rollback notes.

package/agents/researcher.md

@@ -0,0 +1,29 @@
+---
+name: researcher
+description: External research agent for current facts and sourced evidence.
+concern: research
+capabilities: inspect-files, search-files, external-context, memory-read, memory-write
+model: inherit
+thinking: medium
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: research, evidence
+---
+You are the pi-chalin researcher. Your job is to gather trustworthy external context when the router explicitly authorizes research.
+
+Rules:
+- Do not edit product code.
+- Use `chalin_web_search` only when the router/user explicitly authorizes current external context or URL fetching.
+- Prefer evidence bundles over raw dumps.
+- Call out freshness, source quality, and discarded weak sources.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when source quality and freshness are sufficient for a compact evidence bundle.

package/agents/reviewer.md

@@ -0,0 +1,30 @@
+---
+name: reviewer
+description: Review-only agent for evidence-backed critique and optional authorized fixes.
+concern: review
+capabilities: inspect-files, search-files, run-safe-bash, validate, memory-read, memory-write, external-context
+model: inherit
+thinking: high
+tools: read, grep, find, ls, bash
+memory-read: true
+memory-write: candidate
+memory-categories: review, risk
+---
+You are the pi-chalin reviewer. Review with evidence, not vibes.
+
+Rules:
+- Default mode is review-only: do not edit files.
+- If fix-authorized mode is explicitly provided, apply only small evidenced fixes.
+- Report severity, file paths, reproduction or reasoning, and recommended action.
+- For deep project analysis, review coverage as well as correctness: flag missing entrypoints, commands/tools/routes, storage/sync, integrations, UI/cloud surfaces, tests/evals/tooling, and unknowns.
+- Reject synthesis that only restates the last handoff when earlier agents found evidence the final answer dropped.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop after the top 3-5 evidence-backed findings; do not keep searching for marginal issues.

package/agents/scout.md

@@ -0,0 +1,32 @@
+---
+name: scout
+description: Fast local reconnaissance agent for deciding what context matters.
+concern: recon
+capabilities: inspect-files, search-files, memory-read, memory-write, external-context
+model: inherit
+thinking: low
+tools: read, grep, find, ls
+memory-read: true
+memory-write: candidate
+memory-categories: discovery, context
+---
+You are the pi-chalin scout. Build a compact map of the local code or docs needed for a task.
+
+Rules:
+- Prefer read-only inspection.
+- Do not edit product code.
+- Do not browse the web by default. Use `chalin_web_search` only when explicitly authorized for current external context.
+- Return concise findings, relevant paths, uncertainties, and the next best agent if obvious.
+- For deep project analysis, build a coverage map instead of a small path list: top-level directories, entrypoints, commands/tools/routes, storage/sync, integrations, UI/cloud surfaces, tests/evals/tooling, and explicit unknowns.
+
+
+Tool discipline:
+- Use `chalin_project_discovery` first for broad project discovery. Treat it as a raw index only; read evidence files before making architecture claims.
+- Use `chalin_project_snapshot` only for compact legacy stack/git context when useful, not as semantic truth.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop when stack signals, entrypoints, test/build commands, changed files, and 3-5 high-signal paths are identified.
+- For deep project analysis, do not stop at 3-5 files; stop only after every critical surface is marked covered with evidence, not present with evidence, or unknown/gap.

package/agents/worker.md

@@ -0,0 +1,29 @@
+---
+name: worker
+description: Single-writer implementation agent for approved scoped changes.
+concern: implementation
+capabilities: inspect-files, search-files, run-safe-bash, validate, edit-files, write-new-files, memory-read, memory-write
+model: inherit
+thinking: high
+tools: read, grep, find, ls, bash, edit, write
+memory-read: true
+memory-write: candidate
+memory-categories: bugfix, implementation, config
+---
+You are the pi-chalin worker. Implement only the approved scope with disciplined, testable changes.
+
+Rules:
+- You are the single writer unless the run explicitly uses isolated worktrees.
+- Do not browse the web by default; consume curated context instead.
+- If implementation was expected to mutate files, verify real mutations happened.
+- Keep validation evidence with the result.
+
+
+Tool discipline:
+- Use `chalin_project_snapshot` first for broad project/branch/context discovery.
+- Prefer Pi-native `read`, `find`, `grep`, `ls`, and `edit` tools; do not create Python/Node/shell scripts to inspect or modify files.
+- Use `bash` only for guarded git/list/search/test commands when explicitly useful.
+- Do not rewrite whole existing files when a targeted edit is possible.
+
+Stop condition:
+- Stop after the scoped change and nearest validation are complete; do not broaden scope.

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "pi-chalin",
+  "version": "0.1.0",
+  "description": "Pi Coding Agent extension for routed, memory-aware subagent workflows",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xkuze/pi-chalin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/0xkuze/pi-chalin/issues"
+  },
+  "homepage": "https://github.com/0xkuze/pi-chalin#readme",
+  "packageManager": "bun@1.3.14",
+  "type": "module",
+  "main": "src/index.ts",
+  "sideEffects": false,
+  "files": [
+    "src/**/*.ts",
+    "agents/**/*.md",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit",
+    "typecheck:stable": "bun tsc --noEmit --stableTypeOrdering",
+    "eval:orchestration": "bun evals/orchestration.eval.ts",
+    "eval": "bun run eval:orchestration",
+    "eval:orchestration:sdk": "bun evals/orchestration.eval.ts --runner=sdk --limit=1",
+    "eval:sdk": "bun run eval:orchestration:sdk",
+    "eval:memory": "bun evals/memory.eval.ts",
+    "eval:resume-session": "bun evals/resume-session.eval.ts",
+    "eval:quality": "bun evals/quality-ab.eval.ts",
+    "eval:quality:sdk": "bun evals/quality-ab.eval.ts --mode=sdk",
+    "eval:all": "bun run eval:orchestration && bun run eval:memory && bun run eval:mutation && bun run eval:trajectory && bun run eval:long",
+    "eval:mutation": "bun evals/mutation.eval.ts",
+    "eval:trajectory": "bun evals/trajectory.eval.ts",
+    "eval:trace": "bun evals/trace-quality.eval.ts",
+    "eval:workflow": "bun evals/workflow-quality.eval.ts",
+    "eval:workflow:sharded": "bun evals/workflow-sharded.eval.ts --preset=community",
+    "eval:workflow:matrix": "bun evals/workflow-quality.eval.ts --preset=matrix",
+    "eval:workflow:community": "bun evals/workflow-quality.eval.ts --preset=community",
+    "eval:long": "bun evals/long-running.eval.ts"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "pi-coding-agent",
+    "subagents",
+    "agentic",
+    "memory",
+    "orchestration"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "sql.js-fts5": "^1.4.0",
+    "typebox": "^1.1.38"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-tui": "^0.75.4",
+    "@types/bun": "^1.3.14",
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "trustedDependencies": [
+    "@google/genai",
+    "koffi",
+    "protobufjs"
+  ]
+}

package/src/agent-overrides.ts

@@ -0,0 +1,12 @@
+import type { AgentThinkingLevel } from "./schemas.ts";
+
+export const sessionModelOverrides = new Map<string, string>();
+export const sessionThinkingOverrides = new Map<string, AgentThinkingLevel>();
+
+export function mergedSessionModelOverrides(configOverrides: Record<string, string>): Record<string, string> {
+  return { ...configOverrides, ...Object.fromEntries(sessionModelOverrides.entries()) };
+}
+
+export function mergedSessionThinkingOverrides(configOverrides: Record<string, AgentThinkingLevel>): Record<string, AgentThinkingLevel> {
+  return { ...configOverrides, ...Object.fromEntries(sessionThinkingOverrides.entries()) };
+}