@expert-council/pi-package 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Labiey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,505 @@
+# Expert Council
+
+[English](README.md) | [简体中文](README.zh-CN.md)
+
+Expert Council is a local, multi-model, cost-aware expert orchestration system for Pi and MCP hosts such as Codex. It discovers the models connected through Pi's registered LLM APIs and coding plans, combines runtime metadata with user-defined billing policy, capability profiles, and local reliability data, dynamically assembles a small semantic expert team, executes bounded tasks through Pi, and returns compact structured results to the Main Agent.
+
+> ⚠️ **Codex plugin not yet released**: the Codex plugin has not completed functional testing. Its installation and usage documentation is temporarily withheld from this version and is expected to ship with the next official release. For now, use Expert Council through the native Pi Package, the CLI, or the generic MCP Server.
+
+Key advantages:
+
+| Advantage | Description |
+|---|---|
+| Cost savings | Makes flexible use of subscribed plans and LLM APIs, automatically matching the most suitable model to each task's difficulty |
+| Speed | Runs multiple suitable models concurrently, accelerating repository exploration and context compression |
+| Safer | Assigns different read-only/writable permissions per expert; writable experts commit into an isolated Git worktree that the Main Agent reviews before integration |
+| Context savings | The Main Agent no longer carries long tool-call-heavy context; it receives summarized, structured results from experts |
+
+In practice, the theoretically strongest model is not automatically the best executor. A model with stable tool calls, reliable shell behavior, and low marginal cost can deliver more real task value than a stronger but less dependable one. We recommend configuring a cost-effective, execution-strong model as the Main Agent; when a complex problem appears, Expert Council can dispatch strong-reasoning models for review or planning.
+
+## Current status
+
+The current release (0.4.0) includes:
+
+- A host-independent Core: configuration validation, model normalization, billing policy, profile layering, role scoring, task classification, dynamic team sizing, retry/escalation, and telemetry aggregation.
+- An execution runtime built on Pi's current `ModelRuntime` and `createAgentSession` APIs.
+- Hard tool allowlists and installed-Skill filtering for every expert session.
+- Isolated Git worktrees for writable experts.
+- A JSON-capable CLI.
+- An MCP Server with nine asynchronous semantic tools, event-driven completion waits, an acceptance-feedback loop, and explicit worktree cleanup.
+- A native Pi Package.
+- Runtime availability markers: when a call fails with dead-model evidence, the model is recorded into the persisted assessment and hard-rejected by later council building, delegation, and escalation; markers expire and are retried automatically after 24 hours.
+- Provider session error surfacing: upstream denials such as `403 AccessDenied` are no longer swallowed; they return to the Main Agent with the real diagnostic and the correct failure class.
+- Cross-process shared model assessment: with multiple instances running in parallel, availability markers become visible to each other without a restart.
+- A Codex plugin with the shared Skill and a bundled stdio MCP Server (functional testing incomplete; not yet officially released).
+- Deterministic automated tests that never consume model quota.
+
+## Architecture
+
+```text
+Codex or Pi Main Agent
+        |
+        | semantic tools / shared Skill
+        v
+ Expert Council Core
+ - resource and model normalization
+ - billing and capability profiles
+ - deterministic routing
+ - roles and team sizing
+ - retry and escalation
+ - telemetry aggregation
+        |
+        v
+     Pi Runtime
+ - callable model discovery
+ - hard tool allowlists
+ - installed-Skill filtering
+ - bounded expert sessions
+ - workspace isolation
+     /     |      \
+   CLI  Pi Package  MCP Server
+                        |
+                   Codex plugin
+```
+
+TypeScript project references enforce that dependencies flow only in these directions:
+
+```text
+core <- pi-runtime <- cli
+                   <- mcp-server <- codex-integration
+                   <- pi-package
+```
+
+Core does not import Pi, Codex, MCP transport, filesystem, shell, or process APIs. The CLI, MCP Server, and host distributions all use the same service and routing logic.
+
+## Quick start
+
+Requirements:
+
+- Node.js 22.19 or later.
+- npm 11 or a compatible version.
+- Pi installed and configured with at least one usable model.
+- When writable experts need worktree isolation, the Git repository must have at least one commit.
+
+### Install the Pi Package (available after the npm release)
+
+<!-- Placeholder: complete install/upgrade instructions will be added once @expert-council/pi-package is published to npm. -->
+
+```bash
+pi install npm:@expert-council/pi-package
+pi update npm:@expert-council/pi-package
+```
+
+The current version is not yet published to npm; build from source and install locally for now (see "Native Pi Package" below):
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+Discover models without calling any of them:
+
+```bash
+node packages/cli/dist/bin.js models --json
+node packages/cli/dist/bin.js inspect --json
+```
+
+Assemble an expert team without executing any expert:
+
+```bash
+node packages/cli/dist/bin.js build "fix the device hot-swap race condition" --max-experts 4 --json
+```
+
+Delegate only when you are sure actual Pi models should be called:
+
+```bash
+node packages/cli/dist/bin.js delegate architecture-oracle "analyze the concurrent invocation path" --workspace /path/to/repo --json
+```
+
+Zero configuration uses conservative capability defaults, marks unverifiable billing types as `unknown`, and refuses non-isolated writes. It never guesses that an API is free and never infers model quality from a model name.
+
+## Model discovery
+
+`PiExpertRuntime` calls Pi's `ModelRuntime.getAvailable()` instead of using a hardcoded catalog. A model that merely exists in a registry or user profile is not routed to; only models Pi reports as currently callable are used.
+
+The runtime normalizes:
+
+- provider and model ID;
+- display name;
+- reasoning support and the reasoning-level map exposed by Pi;
+- context and maximum output windows;
+- input modalities;
+- published API price fields;
+- safe compatibility metadata.
+
+The runtime resolves a locally installed compatible Pi SDK first, then an explicit `PI_CODING_AGENT_MODULE` directory, then a compatible global npm Pi installation. If all fail, it returns an actionable diagnostic instead of fabricating a model list.
+
+Pi builds this inventory once per session, and provider catalogs can keep stale model names, so `listAvailableModels()` may include a model the upstream can no longer serve. Routing treats such a model as callable until a real attempt fails; this is why failures with dead-model evidence mark the model unavailable in the persisted model assessment (see the routing section below). Markers expire after 24 hours, and a recovered model is retried automatically.
+
+## Configuration
+
+Specify a configuration file through the `EXPERT_COUNCIL_CONFIG` environment variable or the CLI's `--config PATH` flag. Start from [`config/examples/balanced.example.json`](config/examples/balanced.example.json).
+
+Profile precedence:
+
+```text
+built-in conservative defaults
+  < user configuration or optional presets
+  < current-task runtime overrides
+```
+
+Objective runtime metadata is merged separately. Local outcome data influences routing only after at least three samples accumulate, and the adjustment is bounded by `routing.localLearningMaxAdjustment`. Explicit user configuration always wins.
+
+### Billing policy
+
+Supported billing types:
+
+```text
+subscription  metered  quota  free  unknown
+```
+
+Marginal cost and usage preference are two independent fields because published token prices cannot express subscription plans, fixed quotas, local inference, or promotional credits. The Pi Runtime adapter classifies runtime-reported subscription access or named Token Plan catalogs as `subscription`; otherwise a provider whose Pi model catalog exposes non-zero prices is `metered`, and providers without reliable evidence stay `unknown`. `expert_inspect` returns the inference source, and explicit user configuration always has the highest priority. Models within the same metered provider are still compared on specific prices through `routing.apiPriceWeight` (default `0.35`); an all-zero price table is treated as "not provided", never guessed to be free.
+
+```json
+{
+  "billing": {
+    "providers": {
+      "subscription-provider": {
+        "billingType": "subscription",
+        "marginalCostClass": "very-low",
+        "usagePreference": "consume-first"
+      },
+      "scarce-provider": {
+        "billingType": "quota",
+        "marginalCostClass": "scarce",
+        "usagePreference": "escalation-only"
+      }
+    }
+  }
+}
+```
+
+`config/examples/` provides:
+
+- `balanced.example.json`: conservative defaults for zero configuration.
+- `subscription-heavy.example.json`: prioritize subscription capacity, protect scarce quota.
+- `metered-quality.example.json`: separate economical from high-quality metered APIs.
+- `qwen-glm.example.json`: explicitly labeled as a hypothetical user preference, not an objective benchmark.
+
+### Capability profiles
+
+Models can receive user scores from 0 to 10 on these dimensions:
+
+```text
+reasoning planning architecture coding debugging review longContext
+toolReliability bashReliability autonomousExecution speed
+```
+
+Model keys must use the exact `provider/model` returned by `models --json`. Newly discovered models without local profiles receive conservative defaults; stale configuration for unavailable models only produces warnings and never crashes routing.
+
+### Main Agent capability audit and first-council preference
+
+Users do not need to maintain per-model usage priorities. After the Main Agent decides a task deserves a council, if this is the first council in a new conversation and the user has not expressed a preference, it should ask once:
+
+```text
+price first (economy)
+balance price, time, and success rate (balanced)
+speed first (speed)
+```
+
+The Pi Package records the choice in the current Pi session's hidden extension state; later councils in that conversation reuse it automatically unless the user changes it. `economy` boosts cost weights, `speed` boosts the audited speed dimension, and `balanced` uses normal role weights. The legacy `quality` API value remains compatible but is not offered as a default prompt option.
+
+Model capabilities are audited by the Main Agent rather than hand-ranked by users. `expert_inspect` returns a mandatory assessment gate: if there is no audit yet, the audit is older than 30 days, the callable model set changed, or the user explicitly requests a re-audit, the Main Agent must research every callable model listed by the gate using the host's own web tools; `expert_build` will not assemble a council until then. The Main Agent submits a complete `modelAssessment` whose ISO timestamp must come from the host's real clock, whose sources are consolidated into 1–12 URLs, and which contains 0–10 capability dimensions plus verifiable provider access/billing evidence. Future-dated timestamps are reported separately and can be corrected without repeating the web research. If the gate reports the saved assessment is still `current`, the host should omit `modelAssessment` when calling `expert_build`; incomplete, stale, or future-dated replacement snapshots cannot displace a current one. The assessment is stored once per user data directory and reused across conversations and workspaces as long as the callable model set remains compatible; ordinary plan and execution state saves never overwrite the global assessment from a stale in-memory snapshot, and only an explicitly submitted assessment that passes the gate replaces the stored scores. Explicit user billing configuration always outranks the Main Agent's judgment; unverifiable billing stays `unknown`.
+
+Cross-check rather than trust a single leaderboard: the [Artificial Analysis Data API](https://artificialanalysis.ai/data-api/docs) provides coding, agentic, price, throughput, and latency data; [LiveBench](https://livebench.ai/) covers coding and agentic coding; [Arena](https://arena.ai/leaderboard/text) reflects human preference; provider documentation verifies versions, context, tools, and access method. [OpenRouter Rankings](https://openrouter.ai/rankings?category=programming) mostly reflect real-world usage and are only an adoption signal, not proof of model quality. When the gate demands an audit and the host has no web tools, the Main Agent must state the limitation and stop instead of silently using unaudited defaults; Expert Council never auto-installs plugins, Skills, or third-party executables.
+
+### Role weights
+
+Every semantic role has normalized default weights. Implementation Worker emphasizes tool reliability, coding, autonomous execution, and shell reliability; Architecture Oracle emphasizes architecture, planning, long context, and review.
+
+```json
+{
+  "routing": {
+    "roleWeights": {
+      "implementation-worker": {
+        "toolReliability": 0.4,
+        "coding": 0.3,
+        "costEfficiency": 0.1
+      }
+    }
+  }
+}
+```
+
+Weights are re-normalized automatically. `costPolicy: economy` boosts the cost factor, `speed` boosts speed and reduces cost, and the legacy `quality` reduces cost; none of them bypass safety or compatibility hard constraints.
+
+## Semantic roles and team sizing
+
+Roles are defined by task semantics and never bound to a model name:
+
+| Role | Default permissions | Purpose |
+|---|---|---|
+| Planner | read-only | Task decomposition, dependencies, and risks |
+| Scout | read-only | Repository exploration and context compression |
+| Architecture Oracle | read-only | Hard cross-file reasoning and second opinions |
+| Implementation Worker | writable | Bounded code changes and focused testing |
+| Debugger | writable | Reproduce, isolate, fix, and verify |
+| Reviewer | read-only | Regressions, edge cases, and design review |
+| Verifier | read-only | Check reported tests, diffs, and acceptance criteria |
+
+Tiny tasks use one Worker; normal tasks use Worker plus Verifier; complex features use Planner, Worker, Reviewer, and Verifier; complex debugging uses Scout, Debugger, Oracle, and Verifier. `maxExperts` caps team size, and the Main Agent is never duplicated as a redundant `lead` expert.
+
+Task classification and all scoring math are deterministic. Hosts can inspect the selected model, alternatives, scores, and concise reasons before delegating. Council assembly also applies configurable diversity penalties; Reviewers prefer a different provider and inferred model family from earlier members when economical, but role fit and hard constraints still dominate.
+
+## Routing pipeline
+
+```text
+discover currently callable candidate models
+  -> apply hard constraints
+  -> merge capability and profile layers
+  -> score role fit and effective cost
+  -> conservatively apply local outcome adjustments
+  -> rank with stable tie-breaking
+  -> return selection, alternatives, and reasons
+```
+
+Hard constraints reject unavailable or disabled models, incompatible roles, insufficient tool reliability, insufficient context, mutation without runtime support, `escalation-only` resources on routine tasks, and models carrying an active runtime availability marker.
+
+Pi caches its model inventory per session and provider catalogs can keep stale model names, so a council could otherwise be assembled around a model the upstream can no longer serve. When a delegated attempt fails as `provider_error` with dead-model evidence (for example `model_not_found`, unknown or discontinued models, or the runtime's own availability pre-check), the service records a `modelAvailability` marker into the persisted shared model assessment (`EXPERT_COUNCIL_DATA_DIR`, i.e. `%LOCALAPPDATA%/ExpertCouncil/model-assessment.json` on Windows) through an atomic read-modify-write that never reverts a newer snapshot written by another running Pi/Codex instance. The affected `expert_result` names the model in `executionMetadata.unavailableModels` and `risks`, `expert_inspect` warns about active markers, and later `expert_build`, delegation, and escalation hard-reject marked models. Markers are conservative local evidence: they expire after 24 hours, survive freshly submitted audits, and an explicit `modelOverrides["provider/model"].overrideUnavailableMarker: true` re-enables a model. Transient provider failures such as rate limits or authentication errors never create markers. When no saved assessment exists yet, the marker cannot be persisted, but the failure is still reported to the Main Agent and recorded in local telemetry.
+
+Reasoning levels are optional and model-specific. A configured role preference applies only when Pi exposes it for the selected model; otherwise Pi keeps or clamps to the model's supported default.
+
+## Skills and least privilege
+
+The canonical platform-neutral host guidance is [`shared/skills/expert-council/SKILL.md`](shared/skills/expert-council/SKILL.md). The build composes it with the small host overlays under `shared/skills/expert-council/hosts/` into separate Pi and Codex `SKILL.md` artifacts without duplicating the shared workflow. The Pi artifact only describes completion `steer`/`followUp` behavior and never exposes `expert_wait`; only the Codex artifact describes the bounded `expert_wait` flow. Shared role prompts live in `packages/core/src/roles/prompts/` and are copied as package assets rather than rewritten per host.
+
+Read-only roles never receive `edit`, `write`, `bash`, or `powershell`, even if a caller tries to include them. Pi sessions use a real `tools` allowlist, which is stronger than prompt-only guidance. Until a dedicated non-mutating command runner exists, tasks that need shell-driven testing belong to writable roles in isolated worktrees.
+
+Only installed, enabled Pi Skills required by the role are activated. User-scope Skills are trusted by default; project and temporary Skills are excluded unless their exact name is listed in `security.trustedSkills`. Every expert resource loader disables extensions, prompt templates, themes, and project context files, and Pi SDK versions that cannot enforce these policies are rejected. Expert Council never downloads or installs Skills or executable extensions.
+
+Expert prompts require: read before editing, verify paths, prefer targeted edits, diagnose failures before changing approach, use finite non-interactive commands, inspect results, never delegate recursively, and return compact JSON instead of private reasoning.
+
+## Retry and escalation
+
+Failure types are normalized to:
+
+```text
+tool_call_error reasoning_failure test_failure timeout provider_error
+missing_context permission_error unknown
+```
+
+By default, the first correctable tool, context, or test failure receives at most one retry with a changed approach. Repeated relevant failures or provider errors switch to the next eligible, untried model. Attempt and escalation budgets are separately capped; with no candidates or exhausted budget, an unresolved state returns to the Main Agent.
+
+There are no infinite loops, and the same failed action is never repeated blindly by policy.
+
+## Structured results and context efficiency
+
+Expert results contain status, role, model, summary, changed files, tests, findings, risks, recommended next action, failure type, the approximate usage Pi exposes, and bounded execution metadata. The system prefers the expert's own structured failure type and deterministically classifies test, provider, tool, and context failures; unparseable non-JSON output is marked `reasoning_failure`. Private reasoning is never requested or stored, and whole source files are never copied back into the Main Agent's context.
+
+## Workspace safety
+
+The system never assumes that Codex's own sandbox contains the external Pi process. The Pi Runtime uses an independent boundary:
+
+1. Canonicalize the requested workspace path.
+2. Require the path to fall under allowed roots.
+3. Create a detached worktree from the repository's current `HEAD` inside a current-user-private directory under the system temp directory.
+4. Give the Worker write tools inside that worktree.
+5. Return the worktree path and changed-file list.
+6. The Codex or Pi Main Agent inspects, integrates, and finally accepts.
+7. After accepting or rejecting, call `expert_cleanup`. One call removes every worktree created for that execution ID through retries or escalations and returns all removed paths. Unclaimed worktrees are pruned automatically after `security.worktreeRetentionMs` (24 hours by default), and Git metadata is pruned alongside.
+
+Non-Git workspaces refuse writes by default. If in-place mutation is truly required, it must be explicitly enabled:
+
+```json
+{
+  "security": {
+    "workspaceStrategy": "bounded-in-place",
+    "allowInPlaceMutations": true,
+    "allowedWorkspaceRoots": ["/absolute/path/to/project"]
+  }
+}
+```
+
+Read [`SECURITY.md`](SECURITY.md) before enabling.
+
+## Telemetry and local learning
+
+The default user data root is `%LOCALAPPDATA%\ExpertCouncil` on Windows, `$XDG_STATE_HOME/expert-council` or `~/.local/state/expert-council` on Linux, and `~/Library/Application Support/ExpertCouncil` on macOS. The shared `telemetry.jsonl` stores opaque execution outcomes so real reliability can be reused across conversations and workspaces; feedback for the same execution overwrites earlier samples and never double-counts. The shared `model-assessment.json` stores the latest explicit capability and billing scores plus runtime-learned model availability markers. `EXPERT_COUNCIL_DATA_DIR`, `EXPERT_COUNCIL_TELEMETRY`, `EXPERT_COUNCIL_MODEL_ASSESSMENT`, and `EXPERT_COUNCIL_STATE` override locations.
+
+It never records prompts, source content, credentials, API keys, secrets, or reasoning. Aggregate metrics include per-role success rate, first-pass rate, tool error rate, retry rate, verification pass rate, and average attempts. Expert Council has no remote analytics endpoint.
+
+Plans, execution state, and completed structured results remain workspace-scoped in `workspaces/<workspace hash>/state.json`. They survive process restarts; a task still running at restart is closed as an explicit interrupted failure. Legacy in-project `.expert-council` and `%USERPROFILE%\.expert-council` directories are not deleted automatically.
+
+## CLI
+
+The CLI uses exactly the same Core and Pi Runtime as MCP and the Pi Package:
+
+```text
+expert-council models
+expert-council inspect
+expert-council build <task>
+expert-council delegate <role> <task>
+expert-council feedback <execution-id> --verification passed|failed
+expert-council cleanup <execution-id>
+expert-council status
+```
+
+Common flags:
+
+- `--json`: machine-readable output.
+- `--cwd`: project workspace.
+- `--config`: user policy file.
+- `--telemetry`: custom local telemetry path.
+- `--state`: custom path for persisted plans, executions, and results.
+- `--timeout-ms`: expert execution timeout.
+
+## MCP Server
+
+The MCP surface is deliberately limited to nine semantic tools:
+
+- `expert_inspect`
+- `expert_build`
+- `expert_delegate`
+- `expert_wait`
+- `expert_result`
+- `expert_feedback`
+- `expert_cleanup`
+- `expert_escalate`
+- `expert_status`
+
+`expert_inspect` and `expert_build` return compact host-facing views by default. Pass `detail: "full"` only when exact model metadata, alternatives, scores, tools, or Skills are genuinely required.
+
+`expert_delegate` starts background work and immediately returns execution IDs; the original single-assignment parameters remain compatible. The Main Agent should set an explicit `timeoutMs` per assignment based on expected difficulty instead of relying on the runtime's ten-minute fallback. When two or more independent tasks exist, dispatch the entire batch before continuing other Main Agent work:
+
+```json
+{
+  "assignments": [
+    { "role": "scout", "task": "locate relevant files", "taskDescription": "repo mapping", "timeoutMs": 300000 },
+    { "role": "reviewer", "task": "review boundary design", "taskDescription": "boundary review", "timeoutMs": 600000 }
+  ]
+}
+```
+
+`assignments` must be an actual JSON array, never a string containing JSON. The native Pi adapter offers bounded compatibility parsing for models that occasionally stringify the array, but normal callers should emit real arrays.
+
+The optional `taskDescription` is a short host-facing label for identifying the task; it is not part of the expert's actual task content. After dispatching, the Main Agent should continue all independently completable work; when nothing useful remains, call `expert_wait` once with up to eight execution IDs, usually `mode: "all"` (use `"any"` when any early result unblocks progress), and a `timeoutMs` sized to the estimated remaining difficulty. Waiting is driven by execution-promise completion events rather than polling; blocking the current MCP call is expected behavior, and no main-model tokens are consumed while waiting.
+
+```json
+{
+  "executionIds": ["exec_a", "exec_b"],
+  "mode": "all",
+  "timeoutMs": 900000
+}
+```
+
+`expert_wait` returns only completion state and task IDs; fetch the formal feedback with `expert_result` and call `expert_feedback` after the Main Agent's acceptance. `expert_wait.timeoutMs` bounds only that wait and never extends each expert's own execution deadline. Every potentially blocking Expert Council, Bash, PowerShell, or other MCP call must still carry an explicit finite timeout sized to the operation; remaining synchronous Expert Council operations are protected by an independent 30-second in-server cap. `expert_status` returns a bounded per-attempt history. The native Pi Package uses proactive completion notifications and therefore does not expose `expert_wait`.
+
+Start the stdio server directly:
+
+```bash
+node packages/mcp-server/dist/bin.js
+```
+
+Supported environment variables:
+
+- `EXPERT_COUNCIL_WORKSPACE`: default allowed workspace.
+- `EXPERT_COUNCIL_CONFIG`: user JSON configuration.
+- `EXPERT_COUNCIL_TELEMETRY`: local telemetry JSONL path.
+- `EXPERT_COUNCIL_STATE`: persisted plans, executions, and results state path.
+- `EXPERT_COUNCIL_MCP_TIMEOUT_MS`: bounded timeout for synchronous MCP operations, 30000 ms by default.
+- `PI_CODING_AGENT_MODULE`: explicit Pi package directory when automatic resolution fails.
+
+Environment overrides and CLI path flags are trusted operator inputs. In particular, `PI_CODING_AGENT_MODULE` loads executable code, while config, workspace, telemetry, and state paths select local files; never accept them from an untrusted repository, task text, or model output.
+
+## Native Pi Package
+
+Build and install the local candidate from the repository root. Even on Windows, use forward slashes whenever a command may pass through Pi's Bash-compatible shell; an unquoted `.\packages\pi-package` loses its backslashes before reaching Pi.
+
+```bash
+npm run build
+pi install "./packages/pi-package"
+pi list
+pi --verbose
+```
+
+`pi list` should show the configured source and its resolved absolute package directory. A newly started verbose Pi session should list `dist/extension.js`, the `expert-council` Skill, and the eight semantic tools without `expert_wait`. Running Pi processes do not hot-reload a rebuilt or removed package.
+
+Or load it for one run without persisting:
+
+```bash
+pi --verbose -e "./packages/pi-package"
+```
+
+A zero-cost load check simply asks Pi to call `expert_inspect`. A real orchestration check should, in a new conversation, build one read-only council, batch two independent read-only assignments at once, confirm that `expert_delegate` immediately returns execution IDs, then accept each completion with `expert_result` and `expert_feedback`. When testing a writable expert, also confirm that one `expert_cleanup` call reports every retry worktree for the execution in `workspaces` and that `git worktree list` afterwards contains only the main checkout.
+
+Before removing a persistent installation, exit every Pi process that loaded the package, then run from the same repository root:
+
+```bash
+pi remove "./packages/pi-package"
+pi list
+```
+
+If the working directory changed, pass the resolved absolute path instead. PowerShell example:
+
+```powershell
+$ecPiPackage = (Resolve-Path "./packages/pi-package").Path
+pi remove "$ecPiPackage"
+pi list
+```
+
+If removal runs through Pi's Bash-compatible shell, use the forward-slash absolute path printed by `pi list`, for example `pi remove "C:/path/to/ExpertCouncil/packages/pi-package"`. Do not copy the indented relative source shown by `pi list` unless the command is resolved from the same settings-directory context.
+
+Pi loads `dist/extension.js` and the synchronized `expert-council` Skill through the package manifest's `pi.extensions` and `pi.skills`. The extension registers the eight semantic tools; because native Pi already provides completion `steer`/`followUp`, the MCP-only `expert_wait` is omitted. It contains no second routing implementation.
+
+Pi delegation is non-blocking; a single call can start up to eight independent background assignments before returning. When an expert finishes, the extension sends compact JSON containing the completed `executionId` and, only when supplied at dispatch, the `taskDescription`; it never carries feedback directly. Notifications use `steer` while the Main Agent is working and a `triggerTurn` `followUp` when it is idle. The Main Agent then calls `expert_result` for the structured feedback. Dispatch the entire ready batch before ending the turn, and avoid polling or silently waiting afterwards.
+
+## Testing
+
+```bash
+npm test
+npm run typecheck
+npm run build
+npm run pack:check
+npm run validate
+```
+
+`npm run validate` builds first so a fresh clone has the workspace package entries generated before testing. Tests cover model normalization, published prices versus real policy billing, worker reliability, oracle scoring, reviewer diversity, hard constraints, unknown and missing models, team sizing, retries with per-attempt diagnostics, structured failure classification, escalation, retry limits, role permissions, compact host output, configuration validation, telemetry privacy/feedback/usage aggregation, Core host independence, mocked Pi discovery and execution, CLI JSON, MCP schemas, real Pi 0.84.4 extension loading/wrapping and async batch notifications, Pi extension registration, and real Git worktree isolation.
+
+Ordinary tests only use the mock runtime and never call paid models. A real read-only Pi execution requires both an explicit model and an explicit cost acknowledgement:
+
+```powershell
+$env:EXPERT_COUNCIL_LIVE_MODEL = "provider/model"
+$env:EXPERT_COUNCIL_LIVE_CONFIRM = "YES"
+npm run smoke:live:pi
+```
+
+Ordinary validation flows never execute that script.
+
+## Publishing
+
+Run `npm run validate` first, inspect every `npm pack --dry-run` file list, then publish in dependency order:
+
+```text
+@expert-council/core
+@expert-council/pi-runtime
+@expert-council/cli
+@expert-council/mcp-server
+@expert-council/pi-package
+```
+
+## Known limitations
+
+- Pi's API moves quickly. The current release was verified against the local 0.84.4 SDK; the runtime checks required SDK, model-runtime, resource-loader, and session methods and lists any missing contract explicitly on incompatibility.
+- Pi has no unified real billing-type API. Runtime subscription signals and named Token Plans take priority; otherwise non-zero catalog prices are treated as metered, and providers without reliable evidence stay `unknown` until an audit or explicit user configuration confirms them.
+- Expert Council does not infer subjective coding quality from model names, nor does it download benchmark presets automatically.
+- Detached worktrees start from the committed `HEAD` and do not copy uncommitted changes from the main workspace. This is deliberate isolation; the runtime detects a dirty source workspace and surfaces the deviation through runtime limitations and mutation-council warnings before delegation.
+- Worktree changes are returned for Main Agent review and are never auto-merged or applied; call `expert_cleanup` after acceptance or rejection, or they will be cleaned up automatically after the retention window.
+- Writes to non-Git workspaces require explicit in-place mutation authorization.
+- In-flight model calls do not resume after a server restart; persisted state closes them as explicit interrupted failures while preserving plans and completed results.
+- Codex's own sandbox does not automatically contain the external Pi runtime, so Expert Council uses separate allowed roots and worktree boundaries.
+- Expert Council contains no arbitrary third-party package installation, recursive expert trees, graphical interface, remote control plane, or remote telemetry.
+
+## License
+
+MIT; see [`LICENSE`](LICENSE).

package/dist/extension.d.ts

@@ -0,0 +1,7 @@
+import { type ExpertCouncil } from "@expert-council/core";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export interface ExpertCouncilExtensionDependencies {
+    councilFor?: (cwd: string) => Promise<ExpertCouncil>;
+}
+export default function expertCouncilExtension(pi: ExtensionAPI, dependencies?: ExpertCouncilExtensionDependencies): void;
+//# sourceMappingURL=extension.d.ts.map

package/dist/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,aAAa,EAInB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAgGpE,MAAM,WAAW,kCAAkC;IACjD,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;CACtD;AAED,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,EAAE,EAAE,YAAY,EAChB,YAAY,GAAE,kCAAuC,QAkStD"}

package/dist/extension.js

@@ -0,0 +1,372 @@
+import { evaluateModelAssessment, MODEL_ASSESSMENT_JSON_SCHEMA, presentCouncilPlan, presentResourceInventory, resolveModelAssessment, } from "@expert-council/core";
+import { createExpertCouncil } from "@expert-council/pi-runtime";
+import { Type } from "typebox";
+const councils = new Map();
+function councilFor(cwd) {
+    const existing = councils.get(cwd);
+    if (existing)
+        return existing;
+    const created = createExpertCouncil({ cwd });
+    councils.set(cwd, created);
+    return created;
+}
+function output(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }], details: undefined };
+}
+const Role = Type.Union([
+    Type.Literal("planner"),
+    Type.Literal("scout"),
+    Type.Literal("architecture-oracle"),
+    Type.Literal("implementation-worker"),
+    Type.Literal("debugger"),
+    Type.Literal("reviewer"),
+    Type.Literal("verifier"),
+]);
+const Failure = Type.Union([
+    Type.Literal("tool_call_error"),
+    Type.Literal("reasoning_failure"),
+    Type.Literal("test_failure"),
+    Type.Literal("timeout"),
+    Type.Literal("provider_error"),
+    Type.Literal("missing_context"),
+    Type.Literal("permission_error"),
+    Type.Literal("unknown"),
+]);
+const Detail = Type.Optional(Type.Union([Type.Literal("compact"), Type.Literal("full")]));
+const CostPolicySchema = Type.Union([
+    Type.Literal("economy"),
+    Type.Literal("balanced"),
+    Type.Literal("speed"),
+    Type.Literal("quality"),
+]);
+const ModelAssessment = Type.Unsafe(MODEL_ASSESSMENT_JSON_SCHEMA);
+const TaskText = Type.String({ minLength: 1, maxLength: 100_000, pattern: "^[^\\x00]+$" });
+const WorkspacePath = Type.String({ minLength: 1, maxLength: 32_768, pattern: "^[^\\x00]+$" });
+const ExecutionIdentifier = Type.String({ minLength: 1, maxLength: 200, pattern: "^[a-zA-Z0-9_-]+$" });
+const ASSEMBLY_PREFERENCE_ENTRY = "expert-council-assembly-preference";
+function parseStringifiedAssignments(value) {
+    if (typeof value !== "string" || value.length > 1_000_000)
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function omitEmptyModelAssessment(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return args;
+    const candidate = args;
+    const assessment = candidate.modelAssessment;
+    if (!assessment || typeof assessment !== "object" || Array.isArray(assessment))
+        return args;
+    const models = assessment.models;
+    if (!models || typeof models !== "object" || Array.isArray(models) || Object.keys(models).length > 0)
+        return args;
+    const { modelAssessment: _ignored, ...rest } = candidate;
+    return rest;
+}
+function sessionAssemblyPreference(ctx) {
+    const entries = ctx.sessionManager?.getBranch?.() ?? [];
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.type !== "custom" || entry.customType !== ASSEMBLY_PREFERENCE_ENTRY)
+            continue;
+        const policy = entry.data?.costPolicy;
+        if (["economy", "balanced", "speed", "quality"].includes(String(policy)))
+            return policy;
+    }
+    return undefined;
+}
+const DelegationAssignment = Type.Object({
+    role: Role,
+    task: TaskText,
+    taskDescription: Type.Optional(Type.String({
+        minLength: 1,
+        maxLength: 500,
+        description: "Optional concise host-facing label included in the completion notification.",
+    })),
+    councilId: Type.Optional(ExecutionIdentifier),
+    workspace: Type.Optional(WorkspacePath),
+    timeoutMs: Type.Optional(Type.Integer({ minimum: 1000, maximum: 3600000 })),
+});
+export default function expertCouncilExtension(pi, dependencies = {}) {
+    const getCouncil = dependencies.councilFor ?? councilFor;
+    pi.registerTool({
+        name: "expert_inspect",
+        label: "Expert Inspect",
+        description: "Inspect a compact summary of callable Pi resources. Request full detail only when exact model metadata is required.",
+        parameters: Type.Object({ detail: Detail }),
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            const inventory = await (await getCouncil(ctx.cwd)).inspectResources();
+            return output(presentResourceInventory(inventory, params.detail));
+        },
+    });
+    pi.registerTool({
+        name: "expert_build",
+        label: "Expert Build",
+        description: "Build a small deterministic expert council. A current complete model assessment is mandatory; the first council in a Pi conversation also requires a user-selected economy, balanced, or speed preference.",
+        promptGuidelines: [
+            "Before the first council in a conversation, ask the user once to choose economy (lowest effective cost), balanced (cost/time/success), or speed (fastest completion), unless their request already states the choice. Never choose that first preference silently.",
+            "After the first council, omit costPolicy to reuse the session preference. Supply it again only when the user explicitly changes preference.",
+            "When the model-assessment gate reports missing, stale, or inventory-changed, do not build or delegate. Use an already available web/research tool for researchModels only, preserve saved scores for other requiredModels entries, then retry once with a complete dated, sourced modelAssessment. Never install a web tool or third-party package automatically.",
+            "Use the actual host clock for modelAssessment.asOf and 1 to 12 consolidated source URLs. If the gate reports future-dated, keep the existing evidence and scores, correct only the timestamp, and do not browse again.",
+            "When expert_inspect reports modelAssessment.status='current', omit modelAssessment from expert_build and reuse the saved snapshot. Never send an empty or reconstructed assessment.",
+        ],
+        parameters: Type.Object({
+            task: TaskText,
+            maxExperts: Type.Optional(Type.Integer({ minimum: 1, maximum: 8 })),
+            costPolicy: Type.Optional(CostPolicySchema),
+            minimumContextWindow: Type.Optional(Type.Integer({ minimum: 1 })),
+            modelAssessment: Type.Optional(ModelAssessment),
+            detail: Detail,
+        }),
+        prepareArguments(args) {
+            return omitEmptyModelAssessment(args);
+        },
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            const previousPreference = sessionAssemblyPreference(ctx);
+            const requestedPreference = params.costPolicy;
+            if (!previousPreference && !requestedPreference) {
+                return output({
+                    status: "preference-required",
+                    question: "这是本对话第一次组建专家委员会。请选择组建方式：价格优先、综合价格/时间/成功率，或速度优先。",
+                    choices: [
+                        { costPolicy: "economy", label: "价格优先", description: "优先最低有效边际成本。" },
+                        { costPolicy: "balanced", label: "综合平衡", description: "平衡价格、完成时间与成功率。" },
+                        { costPolicy: "speed", label: "速度优先", description: "优先最快完成。" },
+                    ],
+                });
+            }
+            const costPolicy = requestedPreference ?? previousPreference;
+            if (requestedPreference && requestedPreference !== previousPreference) {
+                pi.appendEntry(ASSEMBLY_PREFERENCE_ENTRY, { costPolicy: requestedPreference, recordedAt: new Date().toISOString() });
+            }
+            const council = await getCouncil(ctx.cwd);
+            const inventory = await council.inspectResources();
+            const assessment = resolveModelAssessment(inventory.models, inventory.modelAssessment, params.modelAssessment);
+            if (assessment.status.status === "required") {
+                return output({
+                    ...assessment.status,
+                    assessmentStatus: assessment.status.status,
+                    status: "model-assessment-required",
+                    providerBilling: inventory.billing,
+                    billingSources: inventory.billingSources,
+                    warning: "expert_build did not assemble a council. Complete the required web audit, then retry once with modelAssessment.",
+                });
+            }
+            const plan = await council.buildCouncil({
+                task: params.task,
+                ...(assessment.source === "submitted" && assessment.assessment
+                    ? { modelAssessment: assessment.assessment }
+                    : {}),
+                ...(params.maxExperts !== undefined || params.costPolicy !== undefined || params.minimumContextWindow !== undefined ? {
+                    constraints: {
+                        ...(params.maxExperts ? { maxExperts: params.maxExperts } : {}),
+                        costPolicy,
+                        ...(params.minimumContextWindow ? { minimumContextWindow: params.minimumContextWindow } : {}),
+                    },
+                } : { constraints: { costPolicy } }),
+            });
+            return output({
+                ...presentCouncilPlan({
+                    ...plan,
+                    warnings: [
+                        ...plan.warnings,
+                        ...(assessment.ignoredSubmittedAssessment
+                            ? ["Ignored an incomplete, stale, or future-dated submitted modelAssessment and reused the current saved assessment."]
+                            : []),
+                    ],
+                }, params.detail),
+                assemblyPreference: {
+                    costPolicy,
+                    source: requestedPreference ? "user-selected" : "reused-from-session",
+                },
+            });
+        },
+    });
+    pi.registerTool({
+        name: "expert_delegate",
+        label: "Expert Delegate",
+        description: "Start one or up to eight bounded semantic expert assignments in the background and immediately return execution IDs.",
+        promptGuidelines: [
+            "Dispatch every independent assignment selected for the current batch before ending the turn; prefer the assignments array when two or more tasks are ready.",
+            "Pass assignments as a real JSON array, never as a quoted or stringified JSON value.",
+            "After expert_delegate reports that a task has completed, call expert_result with its executionId before using the feedback.",
+            "After verifying the completed result, call expert_feedback with the same executionId and verification outcome so local routing can learn.",
+            "Native Pi completion notifications wake the Main Agent automatically; after dispatching background work, stop the turn instead of polling or silently waiting when no other useful work remains.",
+        ],
+        parameters: Type.Object({
+            role: Type.Optional(Role),
+            task: Type.Optional(TaskText),
+            taskDescription: Type.Optional(Type.String({
+                minLength: 1,
+                maxLength: 500,
+                description: "Optional concise host-facing label included in the completion notification.",
+            })),
+            councilId: Type.Optional(ExecutionIdentifier),
+            workspace: Type.Optional(WorkspacePath),
+            timeoutMs: Type.Optional(Type.Integer({ minimum: 1000, maximum: 3600000 })),
+            assignments: Type.Optional(Type.Array(DelegationAssignment, { minItems: 1, maxItems: 8 })),
+        }, { additionalProperties: false }),
+        prepareArguments(args) {
+            if (!args || typeof args !== "object" || Array.isArray(args))
+                return args;
+            const candidate = args;
+            return { ...candidate, assignments: parseStringifiedAssignments(candidate.assignments) };
+        },
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            const council = await getCouncil(ctx.cwd);
+            const rawAssignments = parseStringifiedAssignments(params.assignments);
+            if (rawAssignments !== undefined && !Array.isArray(rawAssignments)) {
+                throw new Error("expert_delegate assignments must be a JSON array, not a string or object.");
+            }
+            const batch = Array.isArray(rawAssignments);
+            if (batch && (params.role !== undefined || params.task !== undefined)) {
+                throw new Error("expert_delegate accepts either assignments or a single role/task pair, not both.");
+            }
+            if (!batch && (!params.role || !params.task)) {
+                throw new Error("expert_delegate requires a non-empty assignments array or both role and task for one assignment.");
+            }
+            const inventory = await council.inspectResources();
+            const assessmentStatus = evaluateModelAssessment(inventory.models, inventory.modelAssessment);
+            if (assessmentStatus.status === "required") {
+                return output({
+                    ...assessmentStatus,
+                    assessmentStatus: assessmentStatus.status,
+                    status: "model-assessment-required",
+                    providerBilling: inventory.billing,
+                    billingSources: inventory.billingSources,
+                    warning: "expert_delegate did not start any execution. Complete the required web audit through expert_build first.",
+                });
+            }
+            const requestedAssignments = batch ? rawAssignments : [{
+                    role: params.role,
+                    task: params.task,
+                    ...(params.taskDescription ? { taskDescription: params.taskDescription } : {}),
+                    ...(params.councilId ? { councilId: params.councilId } : {}),
+                    ...(params.workspace ? { workspace: params.workspace } : {}),
+                    ...(params.timeoutMs ? { timeoutMs: params.timeoutMs } : {}),
+                }];
+            const assignments = requestedAssignments.map((assignment) => ({
+                role: assignment.role,
+                task: assignment.task,
+                ...(assignment.taskDescription ? { taskDescription: assignment.taskDescription } : {}),
+                ...(assignment.councilId ? { councilId: assignment.councilId } : {}),
+                ...(assignment.workspace ? { workspace: assignment.workspace } : {}),
+                ...(assignment.timeoutMs ? { timeoutMs: assignment.timeoutMs } : {}),
+            }));
+            const receipts = assignments.map((assignment) => {
+                const handle = council.startDelegation(assignment);
+                void handle.result.then(() => {
+                    try {
+                        const delivery = ctx.isIdle() ? "followUp" : "steer";
+                        const notification = {
+                            executionId: handle.executionId,
+                            ...(assignment.taskDescription ? { taskDescription: assignment.taskDescription } : {}),
+                        };
+                        pi.sendMessage({
+                            customType: "expert-council-completed",
+                            content: JSON.stringify(notification),
+                            display: true,
+                            details: notification,
+                        }, { deliverAs: delivery, triggerTurn: true });
+                    }
+                    catch {
+                        // The originating Pi session may have been replaced or shut down.
+                        // The result remains available through expert_result in the council service.
+                    }
+                });
+                return {
+                    executionId: handle.executionId,
+                    role: assignment.role,
+                    ...(assignment.taskDescription ? { taskDescription: assignment.taskDescription } : {}),
+                    status: "running",
+                };
+            });
+            return output(batch
+                ? { status: "running", executions: receipts }
+                : { executionId: receipts[0].executionId, status: "running" });
+        },
+    });
+    pi.registerTool({
+        name: "expert_result",
+        label: "Expert Result",
+        description: "Retrieve completed expert feedback by execution ID, or report that the task is still running or unknown.",
+        parameters: Type.Object({
+            executionId: ExecutionIdentifier,
+        }),
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            return output(await (await getCouncil(ctx.cwd)).getResult(params.executionId));
+        },
+    });
+    pi.registerTool({
+        name: "expert_feedback",
+        label: "Expert Feedback",
+        description: "Record whether Main Agent verification accepted a completed expert result for local routing telemetry.",
+        parameters: Type.Object({
+            executionId: ExecutionIdentifier,
+            verificationPassed: Type.Boolean(),
+        }),
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            return output(await (await getCouncil(ctx.cwd)).recordFeedback(params));
+        },
+    });
+    pi.registerTool({
+        name: "expert_cleanup",
+        label: "Expert Cleanup",
+        description: "Remove every retry/escalation worktree for an execution after its result has been integrated or rejected.",
+        parameters: Type.Object({
+            executionId: ExecutionIdentifier,
+        }),
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            return output(await (await getCouncil(ctx.cwd)).cleanup(params.executionId));
+        },
+    });
+    pi.registerTool({
+        name: "expert_escalate",
+        label: "Expert Escalate",
+        description: "Choose a corrected retry, alternative model, or bounded stop from failure evidence.",
+        parameters: Type.Object({
+            role: Role,
+            task: TaskText,
+            currentModel: Type.String({ minLength: 3, maxLength: 500, pattern: "^[^\\x00]+$" }),
+            previousFailures: Type.Array(Type.Object({
+                model: Type.String({ minLength: 1, maxLength: 500, pattern: "^[^\\x00]+$" }),
+                type: Failure,
+                summary: Type.String({ minLength: 1, maxLength: 2000, pattern: "^[^\\x00]+$" }),
+            }), { minItems: 1, maxItems: 8 }),
+        }),
+        async execute(_id, params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            return output(await (await getCouncil(ctx.cwd)).escalate({
+                role: params.role,
+                task: params.task,
+                currentModel: params.currentModel,
+                previousFailures: params.previousFailures.map((failure) => ({
+                    model: failure.model,
+                    type: failure.type,
+                    summary: failure.summary,
+                })),
+            }));
+        },
+    });
+    pi.registerTool({
+        name: "expert_status",
+        label: "Expert Status",
+        description: "Return compact council plans, execution states, and local aggregate outcomes.",
+        parameters: Type.Object({}),
+        async execute(_id, _params, signal, _update, ctx) {
+            signal?.throwIfAborted();
+            return output(await (await getCouncil(ctx.cwd)).getStatus());
+        },
+    });
+}
+//# sourceMappingURL=extension.js.map

package/dist/extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.js","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@expert-council/pi-package",
+  "version": "0.4.0",
+  "description": "Native Pi package exposing Expert Council tools and host guidance",
+  "type": "module",
+  "main": "./dist/extension.js",
+  "types": "./dist/extension.d.ts",
+  "files": ["dist", "skills", "README.md", "LICENSE"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/Labiey/expert-council-router.git", "directory": "packages/pi-package" },
+  "homepage": "https://github.com/Labiey/expert-council-router#readme",
+  "bugs": { "url": "https://github.com/Labiey/expert-council-router/issues" },
+  "keywords": ["pi-package", "multi-model", "orchestration"],
+  "publishConfig": { "access": "public" },
+  "pi": {
+    "extensions": ["./dist/extension.js"],
+    "skills": ["./skills"]
+  },
+  "dependencies": {
+    "@expert-council/core": "0.4.0",
+    "@expert-council/pi-runtime": "0.4.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.84.0 <1",
+    "typebox": "^1.3.7"
+  }
+}

package/skills/expert-council/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: expert-council
+description: Use a cost-aware Pi expert council for substantial bounded investigation, implementation, debugging, review, or verification when delegation is likely to save meaningful context, execution effort, or scarce-model quota. Do not use for trivial work.
+---
+
+# Expert Council
+
+Use Expert Council only when delegation is likely to save significant context, execution effort, or effective cost.
+
+1. For a substantial host task, call `expert_inspect` before the first `expert_build`. Treat its `modelAssessment.status` as a protocol gate. Compact output includes the exact required model keys when an audit is required; request `detail: "full"` only for additional metadata.
+2. Before building the first council in a new conversation, establish exactly one assembly preference. If the user has not already stated one, ask whether to optimize for `economy` (lowest effective marginal cost), `balanced` (cost, completion time, and success probability), or `speed` (fastest completion). Stop and wait for the answer. Reuse that choice for later councils in the same conversation; ask again only if the user changes it. The native Pi tool enforces this fallback and stores the choice in session state.
+3. The Main Agent, not the user, assesses which models fit each role. If `modelAssessment.status` is `required`, do not call `expert_build` or `expert_delegate` yet. Use an already available network research tool to cross-check current evidence only for keys in `researchModels`. Preserve saved scores for the remaining `requiredModels` entries. If no network research tool is available, stop and tell the user that the mandatory audit cannot be completed; never silently fall back to unaudited defaults. Never install a browser, Skill, plugin, or executable package automatically.
+4. For the mandatory audit, consider only models returned by `expert_inspect`. Prefer current primary or first-party evidence: Artificial Analysis for coding/agentic scores, price, throughput, and latency; LiveBench for coding and agentic coding; Arena for human preference; provider documentation for model/version/runtime and access-method facts. Treat OpenRouter usage rankings only as adoption evidence, not proof of quality. Triangulate into 1–12 consolidated source URLs, read the actual host clock for `asOf` (never synthesize a future timestamp), normalize only supported capability dimensions to 0–10, merge researched entries with saved entries to cover every `requiredModels` key, and include verified provider billing/access classifications when known; leave them `unknown` rather than guessing. Do not infer personal billing from published per-token prices. Pass the complete result as `modelAssessment` to `expert_build`. If the gate reports `future-dated`, retain the same evidence and scores, correct only `asOf`, and do not browse again. When `modelAssessment.status` is `current`, omit `modelAssessment` from `expert_build` so the saved snapshot is reused; do not send an empty or reconstructed table and do not browse again unless the user requests a re-audit.
+5. Call `expert_build` only after the assessment gate is current, with the task and established cost policy. If the tool still returns `model-assessment-required`, follow its instructions and retry once after completing the audit; do not repeatedly call it unchanged. Let deterministic routing combine the Main Agent assessment, objective Pi metadata, billing policy when known, and locally observed reliability. Do not make the user rank individual models manually and do not assume a newer or more popular model is automatically best for every role.
+6. Delegate bounded semantic assignments by role with `expert_delegate`. It starts background work and immediately returns execution IDs. Set an explicit finite `timeoutMs` for every assignment according to task difficulty instead of relying on the runtime fallback: normally 2–5 minutes for focused read-only work, 10–20 minutes for ordinary implementation/debugging, and at most 30–60 minutes for justified long-running work. When two or more independent assignments are ready, send them together in `assignments` as a real JSON array, never a quoted/stringified JSON value, so the entire batch is dispatched before the host turn ends. Add a short `taskDescription` when recognizing a task later would help.
+7. After dispatching the complete batch, continue any independent Main Agent work. Follow the host-specific completion workflow appended by the distribution; do not poll repeatedly or spend model tokens on an idle loop.
+8. When the host reports a completed `executionId`, call `expert_result` with that exact ID before using the feedback. Prefer read-only investigation before mutation, retain architecture and final acceptance in the Main Agent, and never create a redundant lead expert when the host Main Agent already owns that role.
+9. Verify important results, then call `expert_feedback` so local routing can learn. Inspect isolated worktree changes before integration and call `expert_cleanup` after integrating or rejecting them. Do not delegate trivial work or allow recursive expert delegation.
+10. Use `expert_escalate` only with structured failure evidence. Escalate scarce or expensive models only when corrected retry or economical alternatives are insufficient.
+11. For any provided tool call that may block, use an explicit finite timeout chosen from task difficulty when its schema supports one. A host-level ceiling is only a safety envelope, not the operation's execution budget. Use a bounded operation or the safest available host limit when no per-call timeout exists.
+
+Do not request private reasoning. Use summaries, changed files, tests, findings, risks, and recommended next actions.
+
+## Native Pi completion behavior
+
+After dispatching the complete batch and finishing independent work, end the current turn normally. Native Pi delivers a compact completion notification using `steer` while the Main Agent is working or `followUp` when it is idle, so do not poll or remain in a silent wait. Retrieve each reported execution with `expert_result`.
+
+Choose `expert_delegate.timeoutMs` for every assignment from its expected difficulty. Give potentially blocking Pi shell operations their own finite, difficulty-based timeout whenever the tool supports one.