pi-maestro-teammate 2.8.0 → 2.9.0

package/README.md

@@ -6,7 +6,7 @@ Pi extension for dispatching one or more role-based teammate tasks through a sin
 
 ## Breaking Changes In 1.0
 
-> Current version: **2.8.0**. The 1.0 breaking changes below remain in effect; later releases added circuit breaker, retry resilience, quiet state, duration tracking, observe `watch`/`until=completed`, per-workspace mailbox isolation, lifecycle hardening, and explicit model-registry routing without breaking the v1 public import paths.
+> Current version: **2.8.1**, with `pi-maestro-backends@0.1.7`; Backend-Core 0.1.5 and Settings-Core 0.2.3 remain unchanged. Classifier budgets and diagnostics are session-scoped; child compaction preserves the original task, cumulative search budget, and exact result references. See [RELEASE.md](../../RELEASE.md) for dependency changes and verification limits. The 1.0 breaking changes below remain in effect; later releases added circuit breaker, retry resilience, quiet state, duration tracking, observe `watch`/`until=completed`, per-workspace mailbox isolation, lifecycle hardening, and explicit model-registry routing without breaking the v1 public import paths.
 
 - Every public `teammate` call requires a non-empty `tasks` array.
 - Single-agent work is represented by `tasks` with one item.

package/agents/explorer.md

@@ -31,7 +31,7 @@ From the dispatch prompt, extract:
 3. **Verify** — read the strongest matches to confirm they answer the target; discard weak hits instead of reporting them.
 4. **Report** — emit findings per the Output contract below.
 
-Budget: at most two search rounds beyond the initial pass. Stop there and report what remains unresolved rather than widening endlessly.
+Budget: at most two search rounds beyond the initial pass, or the caller's tighter limit. A round is one bounded batch of queries for unresolved targets, not a separate allowance for each symbol or file. Track rounds cumulatively across compact/new_context; preserve consumed rounds, confirmed findings, negative results, and the exact next action in any handoff. Once the target is answered, return immediately. Do not re-search already-read files merely to polish line citations. At the limit, report what remains unresolved rather than widening endlessly.
 
 ## Output
 

package/agents/planner.md

@@ -33,9 +33,9 @@ Treat a matched template as governing evidence: cite its entry ID in `## Evidenc
 ## Process
 
 1. **Research** — gather governing knowledge (`maestro search` → `maestro load`), verify repository facts yourself, and delegate at most one bounded nested task when it materially helps. Before designing, check for existing decision documents (`docs/*decision*`, `docs/*architecture*`, `maestro search "<topic> 决策|方案"`); when one exists, cite it in `## Evidence` and treat its locked decisions as settled premises — do not re-litigate them in the Plan.
-2. **Design** — lock the technical decisions, affected interfaces and data flow, error behavior, and rejected alternatives whose trade-offs matter.
-3. **Compose** — write the Plan per the Document Contract below.
-4. **Self-check** — confirm every required section and task field is present, every user requirement traces to a planned outcome, and dependencies form an executable DAG before returning.
+2. **Design** — select the smallest end-to-end path using existing authorities. Separate user-required outcomes and explicit human-locked safety/compatibility decisions from agent-selected implementation means; select one approach without treating those means as immutable human requirements.
+3. **Compose** — write the Plan per the Document Contract below, proportionate to the requested outcome. Keep auxiliary diagnostics, provenance, and hardening out of the critical path unless a requirement or confirmed material defect makes them necessary.
+4. **Self-check** — trace every user requirement to an outcome; justify each blocking dependency with its requirement or confirmed defect, not merely an enumerated risk. Make shared input/authority contracts available before consumers need production-path acceptance. Confirm complete coverage and an executable DAG; identify the first end-to-end acceptance milestone, cumulative correction budget, and when to report a simpler equivalent option or need for redesign/user guidance.
 
 ## Output — Document Contract
 
@@ -46,7 +46,7 @@ Return only Markdown for the Plan, with no preface, commentary, interview log, o
 3. `## Evidence`: list governing knowledge or spec IDs, verified code entry points with `file:line` anchors, current behavior, and constraints. Separate verified facts from assumptions.
 4. `## Scope`: list explicit in-scope and out-of-scope boundaries, including compatibility and migration constraints.
 5. `## Requirements`: provide a table with `ID`, `Requirement / source`, `Planned outcome`, and `Acceptance evidence`. Map every user requirement to one or more planned outcomes.
-6. `## Design`: lock technical decisions, affected interfaces and data flow, and error and failure behavior. A Plan describes exactly one selected approach — never present multiple alternative approaches side by side with a recommendation. When alternatives and their trade-offs matter, reference the decision document that settled them in `## Evidence`, or move the unresolved choice to `## Open Decisions`; do not embed an option comparison in the Plan body.
+6. `## Design`: specify the selected implementation, affected interfaces and data flow, and error and failure behavior; label explicit human-locked decisions separately from revisable implementation means. Equivalent simplification must preserve required behavior and guarantees; changes to approved scope, explicit locked decisions, or safety boundaries require renewed approval, never silent gate removal. A Plan describes exactly one selected approach — never present multiple alternative approaches side by side with a recommendation. When alternatives and their trade-offs matter, reference the decision document that settled them in `## Evidence`, or move the unresolved choice to `## Open Decisions`; do not embed an option comparison in the Plan body.
 7. `## Execution Plan`: define ordered, outcome-sized tasks. Every task must contain these fields:
    - `ID`
    - `Outcome`
@@ -57,7 +57,7 @@ Return only Markdown for the Plan, with no preface, commentary, interview log, o
    - `Verification`
    Dependencies must form an executable DAG and identify safe parallel work. A task is a verifiable outcome, not a command or activity log.
 8. `## Validation`: specify exact commands or observable checks, expected results, requirement coverage, and relevant regression or integration boundaries.
-9. `## Risks and Recovery`: state concrete risks, mitigations, and rollback or recovery behavior.
+9. `## Risks and Recovery`: state concrete risks, mitigations, and rollback or recovery behavior. Risks are not automatically acceptance gates; justify any blocking mitigation. Count failed attempts by shared interface/state machine and delivery blocker across workers, task names, approaches, and resets; after three unsuccessful attempts, stop the correction chain and report its effect on the requested outcome plus a simpler equivalent option or need for redesign/user guidance.
 10. `## Knowledge Outcome`: require an end-of-execution assessment after implementation and verification. Name plausible candidate topics only when the work may produce a reusable non-obvious pitfall, failure lesson, trade-off, or prescriptive constraint; otherwise write `None expected` with a concrete reason. This section predicts what to assess—it must not fabricate knowledge in advance. Actual staging happens after approval in Act/Run mode, and the executor must explicitly report zero candidates when no result meets the project's knowledge quality bar.
 11. `## Open Decisions`: list unresolved user-owned decisions. Write `None` only after evidence-based review; a Plan with unresolved decisions is not confirmation-ready.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-maestro-teammate",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Pi extension — teammate agent dispatch with DAG task graphs, RPC messaging, and compact TUI",
   "type": "module",
   "engines": {
@@ -21,6 +21,7 @@
   ],
   "scripts": {
     "test": "node --experimental-transform-types --import ./test/setup.ts --test --test-concurrency=2 \"test/*.test.ts\"",
+    "test:host-observers-packed": "node --test test/host-observers-packed.test.mjs",
     "typecheck": "tsc -p tsconfig.build.json",
     "build:declarations": "tsc -p tsconfig.declarations.json",
     "check:declarations": "node scripts/check-declarations.mjs",
@@ -176,7 +177,7 @@
   },
   "files": [
     "bin/*.mjs",
-    "src/**/*.{ts,json}",
+    "src/**/*.{ts,mjs,json}",
     "types/**/*.d.ts",
     "agents/",
     "README.md"
@@ -216,7 +217,7 @@
     "jiti": "2.7.0",
     "pi-maestro-settings-core": "0.2.3",
     "pi-maestro-backend-core": "0.1.5",
-    "pi-maestro-backends": "0.1.6",
+    "pi-maestro-backends": "0.1.7",
     "pi-maestro-fabric-core": "0.1.0",
     "proper-lockfile": "4.1.2",
     "ssh2": "1.17.0",

package/src/classify/client.ts

@@ -56,9 +56,28 @@ export interface JevClient {
 
 interface PreparedJevDecision {
   identity: string;
+  effectiveModel?: string;
+  /** Present only after native authenticated model resolution. */
+  authenticatedModel?: string;
   decide(): Promise<JevResponse>;
 }
 
+export interface ClassifierRuntimeReadiness {
+  status: "disabled" | "unknown" | "available" | "unavailable";
+  available: boolean;
+  reason?: string;
+  model?: string;
+}
+
+const probes = new WeakMap<JevClient, (signal?: AbortSignal) => Promise<ClassifierRuntimeReadiness>>();
+
+/** @internal Authentication-only probe; never submits a model request. */
+export async function probeJevClient(client: JevClient, signal?: AbortSignal): Promise<ClassifierRuntimeReadiness> {
+  signal?.throwIfAborted();
+  const probe = probes.get(client);
+  return probe ? probe(signal) : { status: "unknown", available: false, reason: "Legacy classifier credentials configured but not verified" };
+}
+
 // Keep preparation internal to these clients: cache identity and execution must
 // use the same resolved native model, even when the host registry changes.
 const preparations = new WeakMap<JevClient, (request: Omit<JevRequest, "model">) => Promise<PreparedJevDecision>>();
@@ -136,19 +155,55 @@ export interface ClassifierRuntime {
   classify(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ModelsClassifierOptions): Promise<ClassifierResult>;
 }
 
-export function createNativeJevClient(runtime: ClassifierRuntime, options: Pick<JevClientOptions, "endpoint" | "model" | "timeoutMs">): JevClient {
+export interface NativeJevClientOptions {
+  /** Absent means auto across authenticated classifier providers. */
+  endpoint?: JevEndpoint;
+  model?: string;
+  timeoutMs?: number;
+}
+
+function nativeSignal(options: NativeJevClientOptions, signal?: AbortSignal): AbortSignal {
+  const timeout = AbortSignal.timeout(Math.max(1, options.timeoutMs ?? JEV_DEFAULT_TIMEOUT_MS));
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+/** One resolver for both execution and readiness; registry entries alone are not auth evidence. */
+async function resolveNativeClassifierModel(runtime: ClassifierRuntime, options: NativeJevClientOptions, signal: AbortSignal): Promise<ClassifierModel<ClassifierApi>> {
+  signal.throwIfAborted();
+  const reference = options.model?.trim() || undefined;
+  const slash = reference?.indexOf("/") ?? -1;
+  const pinnedProvider = slash > 0 ? reference!.slice(0, slash) : undefined;
+  if (options.endpoint && pinnedProvider && pinnedProvider !== options.endpoint) {
+    throw new Error("Native classifier unavailable (model provider conflicts with explicit endpoint)");
+  }
+  const provider = options.endpoint ?? pinnedProvider;
+  let abort!: () => void;
+  const cancelled = new Promise<never>((_resolve, reject) => {
+    abort = () => reject(signal.reason ?? new Error("Classifier probe aborted"));
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+  let available: readonly ClassifierModel<ClassifierApi>[];
+  try {
+    available = await Promise.race([runtime.getAvailableOfType("classifier", provider, { signal }), cancelled]);
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+  const candidates = available.filter((entry) => !provider || entry.provider === provider);
+  // Stable preference within provider tiers: never manufacture a default model.
+  const rank = (entry: ClassifierModel<ClassifierApi>) => entry.provider === "typesafe" ? 0 : entry.provider === "openrouter" ? 1 : 2;
+  const model = reference
+    ? candidates.find((entry) => slash > 0 ? entry.provider === pinnedProvider && entry.id === reference.slice(slash + 1) : entry.id === reference)
+    : candidates.reduce<ClassifierModel<ClassifierApi> | undefined>((best, entry) => !best || rank(entry) < rank(best) ? entry : best, undefined);
+  if (!model) throw new Error("Native classifier unavailable (no matching authenticated classifier model)");
+  return model;
+}
+
+export function createNativeJevClient(runtime: ClassifierRuntime, options: NativeJevClientOptions = {}): JevClient {
   const prepare = async (request: Omit<JevRequest, "model">): Promise<PreparedJevDecision> => {
-    const signal = AbortSignal.timeout(Math.max(1, options.timeoutMs ?? JEV_DEFAULT_TIMEOUT_MS));
-    const provider = options.endpoint;
-    const available = await runtime.getAvailableOfType("classifier", options.model?.includes("/") ? undefined : provider, { signal });
-    const reference = options.model;
-    const slash = reference?.indexOf("/") ?? -1;
-    const model = reference
-      ? (slash > 0
-        ? runtime.getModelOfType("classifier", reference.slice(0, slash), reference.slice(slash + 1))
-        : available.find((entry) => entry.id === reference))
-      : available[0];
-    if (!model) throw new Error("Native classifier unavailable (no matching authenticated classifier model)");
+    const signal = nativeSignal(options);
+    const model = await resolveNativeClassifierModel(runtime, options, signal);
     const questions: ClassifierContext["questions"] = {};
     for (const [id, question] of Object.entries(request.questions)) {
       questions[id] = question.type === "noul"
@@ -159,6 +214,7 @@ export function createNativeJevClient(runtime: ClassifierRuntime, options: Pick<
     }
     return {
       identity: JSON.stringify(["native", options.endpoint, model.provider, model.api, model.baseUrl, model.id]),
+      authenticatedModel: `${model.provider}/${model.id}`,
       async decide() {
         const result = await runtime.classify(model, { state: { text: request.state }, questions }, { signal });
         if (result.stopReason !== "stop") throw new Error(result.errorMessage ?? `Native classifier ${result.stopReason}`);
@@ -174,6 +230,10 @@ export function createNativeJevClient(runtime: ClassifierRuntime, options: Pick<
   };
   const client: JevClient = { decide: async (request) => (await prepare(request)).decide() };
   preparations.set(client, prepare);
+  probes.set(client, async (parent) => {
+    const model = await resolveNativeClassifierModel(runtime, options, nativeSignal(options, parent));
+    return { status: "available", available: true, model: `${model.provider}/${model.id}` };
+  });
   return client;
 }
 
@@ -204,6 +264,7 @@ export function createJevClient(options: JevClientOptions): JevClient {
   };
   preparations.set(client, async (request) => ({
     identity: JSON.stringify(["http", options.endpoint, url, model]),
+    effectiveModel: model,
     decide: () => client.decide(request),
   }));
   return client;

package/src/classify/engine.ts

@@ -29,6 +29,8 @@ import {
   createJevClient,
   createNativeJevClient,
   type ClassifierRuntime,
+  type ClassifierRuntimeReadiness,
+  probeJevClient,
   prepareJevDecision,
   resolveJevEndpoint,
   type JevClient,
@@ -61,7 +63,7 @@ export interface ClassifierConfig {
   timeoutMs?: number;
   /** Answer cache TTL (default 10min — error text repeats heavily). */
   cacheTtlMs?: number;
-  /** Max JEV calls per configure cycle (default 30). */
+  /** Max JEV calls per process-local session + cwd identity (default 30). */
   maxCallsPerSession?: number;
   /** domain name → mode. Absent = "off". */
   domains?: Record<string, ClassifierDomainMode>;
@@ -81,6 +83,9 @@ export interface ClassifierStatus {
   endpoint?: JevEndpoint;
   apiKeyPresent: boolean;
   model?: string;
+  runtimeStatus?: ClassifierRuntimeReadiness["status"];
+  runtimeReason?: string;
+  effectiveModel?: string;
   callsUsed: number;
   maxCalls: number;
   cacheSize: number;
@@ -92,9 +97,22 @@ const DEFAULT_MAX_CALLS = 30;
 
 let config: ClassifierConfig = { enabled: false };
 let client: JevClient | undefined;
-let hostBinding: { hostVersion: string; runtime: ClassifierRuntime } | undefined;
+export interface ClassifierRuntimeBinding {
+  hostVersion: string;
+  runtime: ClassifierRuntime;
+  sessionId?: string;
+  cwd?: string;
+}
+export type { ClassifierRuntimeReadiness } from "./client.ts";
+
+let hostBinding: ClassifierRuntimeBinding | undefined;
 let unavailableReason = "Classifier host runtime unavailable";
-let callsUsed = 0;
+let apiKeyPresent = false;
+let readiness: ClassifierRuntimeReadiness = { status: "disabled", available: false };
+let readinessSequence = 0;
+// Quota survives lifecycle fencing; intentionally no disk persistence.
+let budgetKey = JSON.stringify(["", ""]);
+const budgets = new Map<string, number>();
 const registry = new Map<string, ClassifyDomain<string, unknown>>();
 const cache = new Map<string, { response: JevResponse; at: number }>();
 const pending = new Map<string, Promise<JevResponse>>();
@@ -103,13 +121,13 @@ let generation = {};
 
 function fenceGeneration(): void {
   generation = {};
-  callsUsed = 0;
+  readinessSequence++;
   cache.clear();
   pending.clear();
 }
 
 function captureGeneration() {
-  return { generation, config, client, unavailableReason };
+  return { generation, config, client, unavailableReason, budgetKey, legacy: apiKeyPresent };
 }
 
 type Generation = ReturnType<typeof captureGeneration>;
@@ -119,8 +137,9 @@ function assertCurrent(owner: Generation): void {
 }
 
 /** Bind only the current process's host facade, never a child/remote runtime. */
-export function bindClassifierRuntime(binding: { hostVersion: string; runtime: ClassifierRuntime }): void {
-  hostBinding = binding;
+export function bindClassifierRuntime(binding: ClassifierRuntimeBinding): void {
+  hostBinding = { ...binding };
+  budgetKey = JSON.stringify([binding.sessionId ?? "", binding.cwd ?? ""]);
   configureClassifier(config);
 }
 
@@ -130,6 +149,8 @@ export function unbindClassifierRuntime(runtime: ClassifierRuntime): void {
   hostBinding = undefined;
   client = undefined;
   unavailableReason = "Classifier host runtime unavailable";
+  apiKeyPresent = false;
+  readiness = config.enabled ? { status: "unavailable", available: false, reason: unavailableReason } : { status: "disabled", available: false };
 }
 
 /** Inject classifier configuration (host loads `.pi/classifier.json` / env). */
@@ -139,10 +160,13 @@ export function configureClassifier(next: ClassifierConfig): void {
   const runtime = hostBinding?.runtime;
   const owner = getPiFeatureOwner(hostBinding?.hostVersion ?? next.hostVersion, !!runtime && typeof runtime.classify === "function" && typeof runtime.getAvailableOfType === "function" && typeof runtime.getModelOfType === "function");
   client = undefined;
+  apiKeyPresent = false;
   unavailableReason = "Classifier host runtime unavailable";
+  readiness = config.enabled ? { status: "unavailable", available: false, reason: unavailableReason } : { status: "disabled", available: false };
   if (!config.enabled) return;
   if (owner === "native" && runtime) {
-    client = createNativeJevClient(runtime, { endpoint: next.endpoint ?? "typesafe", model: next.model, timeoutMs: next.timeoutMs });
+    client = createNativeJevClient(runtime, { endpoint: next.endpoint, model: next.model, timeoutMs: next.timeoutMs });
+    readiness = { status: "unknown", available: false, reason: "Native classifier authentication has not been probed" };
     return;
   }
   if (owner !== "legacy") return;
@@ -160,6 +184,33 @@ export function configureClassifier(next: ClassifierConfig): void {
       ...(next.fetchFn ? { fetchFn: next.fetchFn } : {}),
     } as JevClientOptions)
     : undefined;
+  apiKeyPresent = !!resolved;
+  readiness = resolved
+    ? { status: "unknown", available: false, reason: "Legacy classifier credentials configured but not verified" }
+    : { status: "unavailable", available: false, reason: unavailableReason };
+}
+
+/** Refresh authentication/model readiness without spending model-call quota. */
+export async function probeClassifierRuntime(signal?: AbortSignal): Promise<ClassifierRuntimeReadiness> {
+  const owner = captureGeneration();
+  // Legacy probes do not authenticate, so they cannot supersede request evidence.
+  const sequence = owner.legacy ? readinessSequence : ++readinessSequence;
+  if (!owner.config.enabled || !owner.client) return { ...readiness };
+  let result: ClassifierRuntimeReadiness;
+  try {
+    result = await probeJevClient(owner.client, signal);
+  } catch (error) {
+    result = { status: "unavailable", available: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (owner.generation !== generation) {
+    return { status: "unknown", available: false, reason: "Classifier readiness superseded by runtime/config/session generation" };
+  }
+  // A non-verifying legacy probe must preserve same-generation execution evidence.
+  if (owner.legacy && result.status === "unknown") result = { ...readiness };
+  // Concurrent same-generation consumers may use their own auth result, but
+  // only the newest refresh owns the synchronous status projection.
+  if (sequence === readinessSequence && !signal?.aborted) readiness = result;
+  return { ...result };
 }
 
 export function classifierConfig(): ClassifierConfig {
@@ -173,6 +224,10 @@ export function resetClassifierForTest(): void {
   client = undefined;
   hostBinding = undefined;
   unavailableReason = "Classifier host runtime unavailable";
+  apiKeyPresent = false;
+  readiness = { status: "disabled", available: false };
+  budgets.clear();
+  budgetKey = JSON.stringify(["", ""]);
   registry.clear();
 }
 
@@ -196,9 +251,12 @@ export function classifierStatus(): ClassifierStatus {
   return {
     enabled: config.enabled === true,
     ...(config.endpoint ? { endpoint: config.endpoint } : {}),
-    apiKeyPresent: client !== undefined,
+    apiKeyPresent,
     ...(config.model ? { model: config.model } : {}),
-    callsUsed,
+    runtimeStatus: readiness.status,
+    ...(readiness.reason ? { runtimeReason: readiness.reason } : {}),
+    ...(readiness.model ? { effectiveModel: readiness.model } : {}),
+    callsUsed: budgets.get(budgetKey) ?? 0,
     maxCalls: config.maxCallsPerSession ?? DEFAULT_MAX_CALLS,
     cacheSize: cache.size,
     domains,
@@ -245,26 +303,56 @@ async function jevDecide<D extends string, I>(
   assertCurrent(owner);
   if (!owner.client) throw new Error(owner.unavailableReason);
   const questions = domain.questions();
-  const prepared = await prepareJevDecision(owner.client, { state, questions });
+  // Native preparation is auth evidence. Legacy owns status only after cache,
+  // pending or quota admission; a rejected request must not supersede execution.
+  let sequence = owner.legacy ? undefined : ++readinessSequence;
+  let prepared: Awaited<ReturnType<typeof prepareJevDecision>>;
+  try {
+    prepared = await prepareJevDecision(owner.client, { state, questions });
+  } catch (error) {
+    assertCurrent(owner);
+    if (sequence === readinessSequence) readiness = { status: "unavailable", available: false, reason: error instanceof Error ? error.message : String(error) };
+    throw error;
+  }
   assertCurrent(owner);
+  if (prepared.authenticatedModel && sequence === readinessSequence) {
+    readiness = { status: "available", available: true, model: prepared.authenticatedModel };
+  }
   const key = createHash("sha256")
     .update(JSON.stringify([domain.name, prepared.identity, questions, state]))
     .digest("hex");
+  const publishSuccess = (response: JevResponse): JevResponse => {
+    assertCurrent(owner);
+    if (sequence === readinessSequence) readiness = {
+      status: "available", available: true,
+      model: prepared.authenticatedModel ?? response.model ?? prepared.effectiveModel,
+    };
+    return response;
+  };
+  const publishFailure = (error: unknown): void => {
+    if (owner.generation === generation && sequence === readinessSequence) readiness = {
+      status: "unavailable", available: false, reason: error instanceof Error ? error.message : String(error),
+      ...(prepared.authenticatedModel ? { model: prepared.authenticatedModel } : {}),
+    };
+  };
   const entry = cache.get(key);
   if (entry && Date.now() - entry.at <= (owner.config.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS)) {
-    return entry.response;
+    sequence ??= ++readinessSequence;
+    return publishSuccess(entry.response);
   }
   cache.delete(key);
   const existing = pending.get(key);
   if (existing) {
-    const response = await existing;
-    assertCurrent(owner);
-    return response;
+    sequence ??= ++readinessSequence;
+    try { return publishSuccess(await existing); }
+    catch (error) { publishFailure(error); throw error; }
   }
+  const callsUsed = budgets.get(owner.budgetKey) ?? 0;
   if (callsUsed >= (owner.config.maxCallsPerSession ?? DEFAULT_MAX_CALLS)) {
     throw new Error("JEV session call budget exhausted");
   }
-  callsUsed += 1;
+  budgets.set(owner.budgetKey, callsUsed + 1);
+  sequence ??= ++readinessSequence;
   // Reserve before invoking host code, which may re-enter configuration.
   const decision = Promise.resolve().then(() => {
     assertCurrent(owner);
@@ -275,7 +363,10 @@ async function jevDecide<D extends string, I>(
     const response = await decision;
     assertCurrent(owner);
     cache.set(key, { response, at: Date.now() });
-    return response;
+    return publishSuccess(response);
+  } catch (error) {
+    publishFailure(error);
+    throw error;
   } finally {
     // A late old request must not remove a new generation's reservation.
     if (owner.generation === generation && pending.get(key) === decision) pending.delete(key);

package/src/extension/index.ts

@@ -271,8 +271,7 @@ import type {
 } from "../runs/execution.ts";
 import { createForkSnapshot } from "../runs/fork-snapshot.ts";
 import {
-  auxToolCallFallback,
-  auxToolResultFallback,
+  auxToolResultCard,
   renderCompletionOutboxMessage,
   renderMonitorResult,
   renderTeammateCompletionFallbackMessage,
@@ -280,13 +279,14 @@ import {
   renderTeammateStalledMessage,
   renderObserveCall,
   renderObserveResult,
-  renderQuietTeammateAux,
+  teammateCallLine,
   renderTeammateCall,
   renderTeammateListCall,
   renderTeammateListResult,
   renderTeammateResult,
   renderTeammateSendCall,
   renderTeammateSendResult,
+  teammateStatusRow,
 } from "../tui/render.ts";
 import { AttachOverlay } from "../tui/attach-overlay.ts";
 import {
@@ -482,7 +482,7 @@ import {
   registerTeammateChildProxyCaller,
   resolvedRunLocation,
 } from "../runs/child-extensions.ts";
-import { setQuietMode } from "pi-maestro-settings-core/ui";
+import { isQuietMode, setQuietMode } from "pi-maestro-settings-core/ui";
 import {
   aggregateAgentRunPhase,
   diagnoseAgentRuntime,
@@ -743,7 +743,7 @@ export default function registerTeammateExtension(
       const content = typeof message.content === "string"
         ? message.content.replace(/^●\s*/, "")
         : "agent spawned";
-      return renderQuietTeammateAux("teammate-started", content, "success", theme as ExtensionContext["ui"]["theme"]);
+      return teammateStatusRow("teammate-started", content, "success", theme as ExtensionContext["ui"]["theme"]);
     },
   );
 
@@ -842,7 +842,8 @@ export default function registerTeammateExtension(
   let classifierRuntime: ExtensionContext["modelRegistry"] | undefined;
   pi.on("session_start", (_event, ctx) => {
     classifierRuntime = ctx.modelRegistry;
-    bindClassifierRuntime({ hostVersion: PI_VERSION, runtime: classifierRuntime });
+    bindClassifierRuntime({ hostVersion: PI_VERSION, runtime: classifierRuntime,
+      sessionId: ctx.sessionManager.getSessionId(), cwd: ctx.cwd });
   });
   pi.on("session_shutdown", () => {
     if (classifierRuntime) unbindClassifierRuntime(classifierRuntime);
@@ -6928,15 +6929,15 @@ export default function registerTeammateExtension(
     renderCall(args, theme, context) {
       if (context.isPartial === false) return new Text("", 0, 0);
       const lines = typeof args.lines === "number" ? ` · ${args.lines} lines` : "";
-      return renderQuietTeammateAux("teammate-watch", `@${String(args.name ?? "?")}${lines}`, "running", theme)
-        ?? auxToolCallFallback("teammate-watch", theme);
+      return teammateCallLine(theme, "teammate-watch", `@${String(args.name ?? "?")}${lines}`);
     },
 
     renderResult(result, options, theme, context) {
       if (options.isPartial) return new Text("", 0, 0);
       const failed = context.isError || (result as { isError?: boolean }).isError === true;
-      return renderQuietTeammateAux("teammate-watch", failed ? "inspection failed" : "inspected", failed ? "failure" : "success", theme)
-        ?? auxToolResultFallback(result, theme);
+      return isQuietMode()
+        ? teammateStatusRow("teammate-watch", failed ? "inspection failed" : "inspected", failed ? "failure" : "success", theme)
+        : auxToolResultCard("teammate-watch", result, theme, options);
     },
   };
 
@@ -6983,16 +6984,16 @@ export default function registerTeammateExtension(
     renderCall(args, theme, context) {
       if (context.isPartial === false) return new Text("", 0, 0);
       const target = args.name ? `@${String(args.name)}` : `${String(args.waitMs ?? 0)}ms`;
-      return renderQuietTeammateAux("teammate-wait", target, "running", theme)
-        ?? auxToolCallFallback("teammate-wait", theme);
+      return teammateCallLine(theme, "teammate-wait", target);
     },
 
     renderResult(result, options, theme, context) {
       if (options.isPartial) return new Text("", 0, 0);
       const status = result.details?.status ?? "timeout";
       const failed = context.isError || (result as { isError?: boolean }).isError === true;
-      return renderQuietTeammateAux("teammate-wait", status, failed ? "failure" : "success", theme)
-        ?? auxToolResultFallback(result, theme);
+      return isQuietMode()
+        ? teammateStatusRow("teammate-wait", status, failed ? "failure" : "success", theme)
+        : auxToolResultCard("teammate-wait", result, theme, options);
     },
   };
 
@@ -9637,9 +9638,9 @@ Use list for an attention-first overview, get for one complete normalized window
         details: query,
       };
     },
-    renderCall(_args, theme, context) {
+    renderCall(_args: Record<string, unknown>, theme, context) {
       if (context.isPartial === false) return new Text("", 0, 0);
-      return auxToolCallFallback("monitor", theme);
+      return teammateCallLine(theme, "monitor", String(_args.action ?? "list"));
     },
     renderResult(result, options, theme, context) {
       return renderMonitorResult(result, options, theme, context.isError);
@@ -9720,15 +9721,15 @@ Use list for an attention-first overview, get for one complete normalized window
       if (context.isPartial === false) return new Text("", 0, 0);
       const action = String(args.action ?? "status");
       const targets = Array.isArray(args.targets) ? (args.targets as string[]).join(", ") : "";
-      return renderQuietTeammateAux("teammate-monitor", `${action} ${targets}`, "running", theme)
-        ?? auxToolCallFallback("teammate-monitor", theme);
+      return teammateCallLine(theme, "teammate-monitor", `${action} ${targets}`);
     },
 
     renderResult(result, options, theme, context) {
       if (options.isPartial) return new Text("", 0, 0);
       const failed = context.isError || (result as { isError?: boolean }).isError === true;
-      return renderQuietTeammateAux("teammate-monitor", failed ? "failed" : "ok", failed ? "failure" : "success", theme)
-        ?? auxToolResultFallback(result, theme);
+      return isQuietMode()
+        ? teammateStatusRow("teammate-monitor", failed ? "failed" : "ok", failed ? "failure" : "success", theme)
+        : auxToolResultCard("teammate-monitor", result, theme, options);
     },
   };
 
@@ -9950,13 +9951,13 @@ This lifecycle tool is available only after the user enters Monitor mode with /m
         created.handle,
       );
     },
-    renderCall(_args, theme, context) {
+    renderCall(_args: Record<string, unknown>, theme, context) {
       if (context.isPartial === false) return new Text("", 0, 0);
-      return auxToolCallFallback("workspace-window", theme);
+      return teammateCallLine(theme, "workspace-window", String(_args.action ?? ""));
     },
     renderResult(result, options, theme) {
       if (options.isPartial) return new Text("", 0, 0);
-      return auxToolResultFallback(result, theme);
+      return auxToolResultCard("workspace-window", result, theme, options);
     },
   };
 
@@ -10057,13 +10058,13 @@ This Monitor-only lifecycle tool loads configured target ids without exposing SS
         return result(sanitizeRemoteMonitorError(error, "worker operation"), true);
       }
     },
-    renderCall(_args, theme, context) {
+    renderCall(_args: Record<string, unknown>, theme, context) {
       if (context.isPartial === false) return new Text("", 0, 0);
-      return auxToolCallFallback("remote-worker", theme);
+      return teammateCallLine(theme, "remote-worker", String(_args.action ?? ""));
     },
     renderResult(result, options, theme) {
       if (options.isPartial) return new Text("", 0, 0);
-      return auxToolResultFallback(result, theme);
+      return auxToolResultCard("remote-worker", result, theme, options);
     },
   };
 

package/src/extension/monitor.ts

@@ -76,6 +76,8 @@ const MONITOR_MODE_CONTEXT = [
   "## Complete-project orchestration",
   "For a complete software project, begin with monitor list and relevant lifecycle list tools to inventory existing work and reuse suitable workers. Never dispatch an undivided project objective directly to implementation. If no decision-complete plan exists, create one read-only planning or technical-lead worker to inspect project knowledge and current code and return requirements, architecture, interfaces, risks, acceptance criteria, and a dependency-aware phase plan. Read its exact completion resource, then bring only genuine product or architecture decisions to the user.",
   "After decisions are locked, execute a phase DAG. Every worker objective must state purpose, owned scope, dependencies, locked interfaces, acceptance criteria, focused verification, and required result resources. Create only runnable workers, parallelize only independent scopes, and keep each shared interface or state machine under one owner until stable. Use explicit phase barriers for dependencies between different windows; never infer dependency completion from timing or message delivery.",
+  "Prioritize the smallest end-to-end path to the user-required outcome using existing authorities. Separate explicit locked constraints from agent-selected implementation means; justify every blocking edge with a requirement or confirmed material defect. Auxiliary diagnostics, provenance, or hardening do not automatically gate unrelated delivery. Make shared authorities available before consumers need production-path acceptance; reconcile an unnecessary gate with the root/user instead of bypassing it, and obtain renewed approval for scope, explicit locked-decision, or safety-boundary changes.",
+  "Track failed attempts cumulatively by shared interface/state machine and delivery blocker across workers, task names, approaches, and resets. After three unsuccessful attempts, stop the correction chain and report its effect on the requested outcome, evidence, and a simpler equivalent option or need for redesign/user guidance. Reuse an existing execution worker for bounded corrections; do not create a new worker merely to reset the budget. If direct execution is needed, ask the user to exit Monitor first; this control window remains supervision-only.",
   "At a phase barrier, establish lifecycle state with monitor or observe as appropriate, then read exact completion resources and correlated Flow reports before accepting work; settled windows alone do not prove project success. Reuse still-valid verification evidence, diagnose failed or ambiguous work before retrying, and dispatch integration, review, or verification only after its dependencies pass. The project is ready only when integrated behavior and acceptance criteria are verified. Release or deployment is not implied by implementation: it requires explicit user authorization and a dedicated worker.",
   "## Tool routing",
   "Use workspace-window only for local Pi workers. Create only a required worker; native interactive is the default. provider=herdr requires an already-running local Herdr session, supports interactive presentation only, and never starts or stops the Herdr server. Create already delivers the objective, so do not resend it. Retain the returned exact owner target and completion handle, read settled results through its immutable agent:// resource, and close only windows created by this Monitor; never close discovered external peers.",

package/src/extension/teammate-core.ts

@@ -109,9 +109,6 @@ import type {
   NormalizedTask,
 } from "../runs/execution.ts";
 import {
-  auxToolCallFallback,
-  auxToolResultFallback,
-  renderQuietTeammateAux,
   renderTeammateCall,
   renderTeammateListCall,
   renderTeammateListResult,