stageflow 0.40.0 → 0.44.0

package/dist/agents/hostContext.d.ts

@@ -9,12 +9,15 @@ import type { ContactInfo } from "../channels/types.js";
 import type { McpToolDeps } from "../mcp/deps.js";
 import { AgentService, type AgentEnvironment } from "./service.js";
 import type { ConversationBackend } from "./sessions.js";
+import { EvalGateRegistry } from "./evalGate.js";
 import { PublicWebChat } from "./webChat/publicChat.js";
 export type AgentHostContext = {
     service: AgentService;
     inbound: AgentInboundRouter;
     publicChat: PublicWebChat;
     chat: AgentChatController;
+    /** Eval tool gates by session id; the eval runner registers a gate for each eval session it opens. */
+    evalGates: EvalGateRegistry;
     backend: ConversationBackend;
     /** Streams held open to AgentMail and iMessage; absent unless the Host listens (not in tests). */
     channelListeners?: ChannelSupervisor;
@@ -50,5 +53,5 @@ export declare function createAgentHostContext(options: {
     /** Host services the Stageflow tools need; agent services are added here. Without it agents get no Stageflow tools. */
     /** Hold streams open to AgentMail and iMessage for agents linked to them. Only a running Host does this. */
     listenOnChannels?: boolean;
-    toolkitDeps?: Pick<McpToolDeps, "manager" | "store" | "agentDir" | "providerAuthContext" | "projectRoot" | "providerBoot">;
+    toolkitDeps?: Pick<McpToolDeps, "manager" | "store" | "agentDir" | "providerAuthContext" | "projectRoot" | "providerBoot" | "channels" | "memories" | "evalRunManager">;
 }): AgentHostContext;

package/dist/agents/hostContext.js

@@ -12,6 +12,7 @@ import { buildToolkit } from "../toolkit/index.js";
 import { createPiAgentRuntime } from "./runtime/piRuntime.js";
 import { AgentService } from "./service.js";
 import { getModelCatalog } from "../models/catalog.js";
+import { EvalGateRegistry } from "./evalGate.js";
 import { defaultAgentProjectRoot } from "./projectRoot.js";
 import { PublicWebChat } from "./webChat/publicChat.js";
 import { AgentStore } from "./store.js";
@@ -82,9 +83,11 @@ export function createAgentHostContext(options) {
                 }
                 : {}),
         });
+    const evalGates = new EvalGateRegistry();
     const chat = new AgentChatController({
         service,
         backend,
+        evalGates,
         otlpSink: "otlpSink" in options ? options.otlpSink : otlpSinkFromEnv(),
         logError: (message) => console.error(message),
     });
@@ -147,7 +150,7 @@ export function createAgentHostContext(options) {
         delivery.start();
     if (options.listenOnChannels)
         void inbound.resumeInterrupted().catch((error) => console.error(`agent resume failed: ${String(error)}`));
-    return { service, chat, backend, inbound, publicChat, channelContact, ...(channelListeners ? { channelListeners } : {}), delivery, stop: async () => {
+    return { service, chat, evalGates, backend, inbound, publicChat, channelContact, ...(channelListeners ? { channelListeners } : {}), delivery, stop: async () => {
             delivery.stop();
             await channelListeners?.stop();
             // The Host owns every runtime session's lifetime: nothing outlives it.

package/dist/agents/runtime/piRuntime.d.ts

@@ -1,4 +1,4 @@
-import { type AgentSession } from "@earendil-works/pi-coding-agent";
+import { type AgentSession, type ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { type AgentDefinition } from "../../config/loadAgent.js";
 import { type StageMemory } from "../../memory/access.js";
 import { type SandboxRunner } from "../sandbox.js";
@@ -34,10 +34,12 @@ export type OpenSessionInput = {
         reason: string;
         terminate?: boolean;
     } | undefined>;
-    delegateTool?: (agentId: string, message: string) => Promise<string>;
+    delegateTool?: (agentId: string, message: string, callId: string) => Promise<string>;
     /** Stageflow tools this agent is granted. */
     stageflowTools?: ToolkitTool[];
     memory?: StageMemory;
+    /** Defaults to true; one-shot judge sessions have no use for it. */
+    workingState?: boolean;
     hooks: () => TurnHooks | undefined;
 };
 export type OpenedSession = {
@@ -48,5 +50,7 @@ export type OpenedSession = {
     toolNames: string[];
     shutdown(): Promise<void>;
 };
+/** Runs the agent tool gate before every call, except for tools the session wiring marks as internal. */
+export declare function createAgentGateExtension(gate: OpenSessionInput["gate"], isInternalTool: (toolName: string) => boolean): ExtensionFactory;
 export declare const DEFAULT_IDLE_RELEASE_MS: number;
 export declare function createPiAgentRuntime(options: PiRuntimeOptions): ConversationBackend;

package/dist/agents/runtime/piRuntime.js

@@ -1,11 +1,13 @@
 import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { defineTool, ModelRuntime, resolveCliModel, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { defineTool, ModelRuntime, resolveCliModel, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { collectMcpExtensionToolNames, mcpToolMetadataMissing } from "../../agent/piAdapter.js";
 import { attachIsolatedMcp } from "../../agent/piIsolatedMcp.js";
 import { warmIsolatedMcpMetadata } from "../../agent/piIsolatedMcpProbe.js";
 import { createPiAgentSession, createSealedResourceLoader } from "../../agent/piSessionFactory.js";
+import { createPiSettingsManager } from "../../agent/piSettings.js";
+import { createSessionContextWiring } from "../../compaction/sessionWiring.js";
 import { bindCursorApiKey, isCursorModelRef } from "../../agent/cursorProvider.js";
 import { findProviderSupport } from "../../agent/providerSupport.js";
 import { grantedBuiltinTools } from "../../config/loadAgent.js";
@@ -19,11 +21,22 @@ import { isUsableAuthFile, resolveCredentialBinding } from "../../runtime/creden
 import { getModelCatalog } from "../../models/catalog.js";
 import { AgentError } from "../errors.js";
 import { MEMORY_STORE_BASH_DENIED, memoryStorePathInCommand } from "../../memory/bashDeny.js";
+import { compactionUsageCost } from "../../agent/compactionEvents.js";
 import { memoryHome } from "../../memory/host.js";
 import { forbiddenWriteTarget } from "../policy.js";
 import { prepareExecutionLaunch } from "../sandbox.js";
 import { grantedStageflowTools, isOperatorOnlyTool } from "../../toolkit/index.js";
 import { grantIdForPiTool, STAGEFLOW_PI_PREFIX } from "./types.js";
+/** Runs the agent tool gate before every call, except for tools the session wiring marks as internal. */
+export function createAgentGateExtension(gate, isInternalTool) {
+    return (pi) => {
+        pi.on("tool_call", async (event) => {
+            if (isInternalTool(event.toolName))
+                return undefined;
+            return gate({ toolCallId: event.toolCallId, toolName: event.toolName, input: event.input });
+        });
+    };
+}
 function piToolNames(definition) {
     return grantedBuiltinTools(definition);
 }
@@ -84,7 +97,7 @@ async function openPiSession(options, input) {
     try {
         await mkdir(options.agentDir, { recursive: true });
         const modelRuntime = await ModelRuntime.create({ authPath, modelsPath: path.join(path.dirname(authPath), "models.json") });
-        const settingsManager = SettingsManager.inMemory({ compaction: { enabled: true } });
+        const settingsManager = createPiSettingsManager();
         const mcpServers = Object.keys(definition.tools.mcp);
         const resolvedMcp = mcpServers.length > 0
             ? await resolveStageMcpServers({ projectRoot, allowlist: mcpServers, env: {}, scope: { kind: "agent" } })
@@ -97,18 +110,18 @@ async function openPiSession(options, input) {
                 throw new AgentError("agent.backend_unavailable", `Skill "${name}" is not installed`);
             skillPaths.push(skill.filePath);
         }
-        const gateExtension = (pi) => {
-            pi.on("tool_call", async (event) => {
-                const outcome = await input.gate({ toolCallId: event.toolCallId, toolName: event.toolName, input: event.input });
-                return outcome;
-            });
-        };
-        const extensionFactories = [{ name: "stageflow-agent-gate", factory: gateExtension }, ...(attached.extensionFactories ?? [])];
+        const contextWiring = createSessionContextWiring({ workingState: input.workingState !== false });
+        const gateExtension = createAgentGateExtension(input.gate, contextWiring.isInternalTool);
+        const extensionFactories = [
+            { name: "stageflow-agent-gate", factory: gateExtension },
+            ...contextWiring.extensions,
+            ...(attached.extensionFactories ?? []),
+        ];
         const loader = createSealedResourceLoader({
             cwd: projectRoot,
             agentDir: options.agentDir,
             settingsManager,
-            systemPrompt: input.systemPrompt,
+            systemPrompt: contextWiring.guidance ? `${input.systemPrompt}\n\n${contextWiring.guidance}` : input.systemPrompt,
             additionalExtensionPaths: extensionPaths,
             ...(skillPaths.length > 0 ? { additionalSkillPaths: skillPaths } : {}),
             extensionFactories,
@@ -127,6 +140,7 @@ async function openPiSession(options, input) {
             throw new AgentError("agent.backend_unavailable", `Failed to load extension(s): ${errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
         }
         const toolNames = [...input.toolNames];
+        toolNames.push(...contextWiring.toolNames);
         if (attached.extensionFactories) {
             const mcp = collectMcpExtensionToolNames(loader);
             if (!mcp.ok)
@@ -149,8 +163,9 @@ async function openPiSession(options, input) {
                     label: `Ask ${agentId}`,
                     description: `Hand a task to the "${agentId}" agent and get its reply.`,
                     parameters: Type.Object({ message: Type.String({ description: "The task or question for the agent." }) }),
-                    execute: async (_id, args) => {
-                        const reply = await input.delegateTool(agentId, args.message);
+                    constrainedSampling: { type: "json_schema", strict: "prefer" },
+                    execute: async (callId, args) => {
+                        const reply = await input.delegateTool(agentId, args.message, callId);
                         return { content: [{ type: "text", text: reply }], details: {} };
                     },
                 }));
@@ -159,7 +174,10 @@ async function openPiSession(options, input) {
         }
         if (input.memory) {
             for (const definition of memorySession(input.memory).tools) {
-                customTools.push(defineTool(definition));
+                customTools.push(defineTool({
+                    ...definition,
+                    constrainedSampling: { type: "json_schema", strict: "prefer" },
+                }));
                 toolNames.push(definition.name);
             }
         }
@@ -169,6 +187,7 @@ async function openPiSession(options, input) {
                 label: tool.name,
                 description: tool.description,
                 parameters: Type.Unsafe(tool.parameters),
+                constrainedSampling: { type: "json_schema", strict: "prefer" },
                 execute: async (_id, args, signal) => {
                     const result = await tool.run(args ?? {}, { signal: signal ?? new AbortController().signal, caller: { agentId: definition.id, definition } });
                     if (!result.ok)
@@ -296,7 +315,7 @@ export function createPiAgentRuntime(options) {
             hooks: () => state.hooks,
             ...(memory ? { memory } : {}),
             ...(stageflowTools.length > 0 ? { stageflowTools } : {}),
-            ...(subAgents.length > 0 ? { delegateTool: (agentId, message) => state.hooks.delegate(agentId, message) } : {}),
+            ...(subAgents.length > 0 ? { delegateTool: (agentId, message, callId) => state.hooks.delegate(agentId, message, callId) } : {}),
             gate: async (call) => {
                 const hooks = state.hooks;
                 if (!hooks)
@@ -334,6 +353,7 @@ export function createPiAgentRuntime(options) {
             let text = "";
             const usage = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
             let startedAt = new Date();
+            let compactionStartedAt;
             const calls = new Map();
             // A model call that goes quiet (provider queue, dropped connection) must not hold the session forever.
             // Waiting on a person (approval), a running tool or a sub-agent is not a stall.
@@ -370,7 +390,20 @@ export function createPiAgentRuntime(options) {
             const unsubscribe = session.subscribe((event) => {
                 arm();
                 const e = event;
-                if (e.type === "message_start" && e.message?.role === "assistant")
+                if (e.type === "compaction_start")
+                    compactionStartedAt = new Date();
+                else if (e.type === "compaction_end") {
+                    const end = event;
+                    const info = compactionUsageCost(end);
+                    usage.inputTokens += info.inputTokens;
+                    usage.outputTokens += info.outputTokens;
+                    usage.costUsd += info.costUsd;
+                    const model = session.model?.id;
+                    if (end.result?.usage) {
+                        input.hooks.modelFinished({ startedAt: compactionStartedAt ?? new Date(), endedAt: new Date(), ...info, ...(model ? { model } : {}) });
+                    }
+                }
+                else if (e.type === "message_start" && e.message?.role === "assistant")
                     startedAt = new Date();
                 else if (e.type === "message_update" && e.assistantMessageEvent?.type === "text_delta" && typeof e.assistantMessageEvent.delta === "string") {
                     text += e.assistantMessageEvent.delta;
@@ -433,8 +466,9 @@ export function createPiAgentRuntime(options) {
             const opened = await open({
                 projectRoot: input.projectRoot,
                 definition: { ...input.definition, tools: { ...input.definition.tools, builtin: [], builtin_tools: [], mcp: {}, skills: [] }, sub_agents: [] },
-                systemPrompt: "You are a strict evaluator. Answer only with the requested number.",
+                systemPrompt: input.systemPrompt ?? "You are a strict evaluator. Answer only with the requested number.",
                 toolNames: [],
+                workingState: false,
                 gate: async () => ({ block: true, reason: "No tools" }),
                 hooks: () => undefined,
             });

package/dist/agents/runtime/types.d.ts

@@ -39,7 +39,7 @@ export type TurnHooks = {
         model?: string;
     }): void;
     /** Run another agent for a `agent:<id>` call and return its reply. */
-    delegate(agentId: string, message: string): Promise<string>;
+    delegate(agentId: string, message: string, callId?: string): Promise<string>;
 };
 export type CompleteInput = {
     sessionId: string;
@@ -64,6 +64,8 @@ export type ConversationBackend = {
         projectRoot: string;
         definition: AgentDefinition;
         prompt: string;
+        /** Replaces the default "strict evaluator" system prompt. */
+        systemPrompt?: string;
         signal: AbortSignal;
     }): Promise<string>;
     /** Drop any cached model session for a conversation session. */

package/dist/agents/service.d.ts

@@ -3,6 +3,7 @@ import { type AgentInboundMessage } from "./communications/port.js";
 import { ApprovalBroker } from "./approvalBroker.js";
 import { type DeliveryLedger, type ScheduleLedger } from "./ledgers.js";
 import { type FinishInput } from "./turnLifecycle.js";
+import { type EvalSessionOverrides } from "./evalSession.js";
 import { type DiffLine } from "./lineDiff.js";
 import { AgentStore, type AgentApproval, type AgentEvalScore, type AgentMessage, type AgentRevision, type AgentRevisionMeta, type AgentSession, type AgentSessionListItem, type AgentDelivery, type AgentSpan, type AgentTurn, type ApprovalActor, type RevisionSource, type SessionQuery, type SessionStats, type SessionStatus } from "./store.js";
 /** Lookups outside the agents directory, used only to produce non-blocking warnings. */
@@ -88,6 +89,8 @@ export declare class AgentService {
     private readonly environment;
     private readonly now;
     private readonly tails;
+    /** Overrides of open eval sessions. Memory only: eval sessions do not survive a Host restart. */
+    private readonly evalOverrides;
     /** Wakes a turn paused at an ask-first tool when its approval is decided. */
     readonly approvalBroker: ApprovalBroker;
     /** Owns every legal change of a turn, its session and its approval. */
@@ -140,6 +143,25 @@ export declare class AgentService {
     get(projectRoot: string, agentId: string): Promise<AgentDetail>;
     /** The definition a session is pinned to. */
     definitionAt(projectRoot: string, agentId: string, revision: number): Promise<AgentDefinition>;
+    /** The pinned definition, with an eval session's overrides applied. Real sessions get it unchanged. */
+    private effectiveDefinition;
+    /** The overrides an eval session was opened with (sub-agent sessions inherit them), or undefined for a real session. */
+    evalOverridesOf(sessionId: string): EvalSessionOverrides | undefined;
+    /** Every eval session below this one (sub-agents and theirs). */
+    listChildSessions(sessionId: string): AgentSession[];
+    /** Delete eval sessions and everything below them. Refuses a session that is not an eval session. */
+    deleteEvalSessions(projectRoot: string, sessionIds: string[]): Promise<string[]>;
+    /**
+     * Boot cleanup of eval sessions: those of the given (recovered) eval runs, and older root sessions no eval result
+     * references. Returns how many sessions were deleted, descendants included.
+     */
+    sweepEvalSessions(input: {
+        runIds: string[];
+        olderThanMs: number;
+        isReferenced: (sessionId: string) => Promise<boolean> | boolean;
+    }): Promise<number>;
+    /** Forget a finished eval session's in-memory overrides. The rows stay readable. */
+    forgetEvalSession(sessionId: string): void;
     private warningsFor;
     /**
      * Web chat defaults and links: a new agent starts with web chat on, an enabled block without a link
@@ -182,10 +204,11 @@ export declare class AgentService {
         sourceRef?: string | null;
         threadKey?: string | null;
         title?: string | null;
+        eval?: EvalSessionOverrides;
     }): Promise<AgentSession>;
     /** Id of the session's pending approval, if a turn is waiting on a person. */
     pendingApprovalFor(_projectRoot: string, sessionId: string): string | null;
-    listSessionsForRef(projectRoot: string, agentId: string, source: string, sourceRef: string, limit: number): AgentSession[];
+    listSessionsForRef(projectRoot: string, agentId: string, source: string, sourceRef: string, limit: number, includeEval?: boolean): AgentSession[];
     private sessionInProject;
     getSession(projectRoot: string, sessionId: string): Promise<AgentSessionDetail>;
     listSessions(projectRoot: string, agentId: string, query: SessionQuery): Promise<{
@@ -274,7 +297,9 @@ export declare class AgentService {
         turnId?: string | null;
     }): Promise<AgentApproval>;
     decideApproval(projectRoot: string, sessionId: string, decision: "approve" | "deny", actor: ApprovalActor): Promise<AgentApproval>;
-    pendingApprovals(projectRoot: string): Promise<Array<AgentApproval & {
+    pendingApprovals(projectRoot: string, options?: {
+        includeEval?: boolean;
+    }): Promise<Array<AgentApproval & {
         agentId: string;
     }>>;
     receive(projectRoot: string, message: AgentInboundMessage): Promise<{

package/dist/agents/service.js

@@ -11,6 +11,7 @@ import { ApprovalBroker } from "./approvalBroker.js";
 import { deliveryLedger, scheduleLedger } from "./ledgers.js";
 import { TurnLifecycle } from "./turnLifecycle.js";
 import { AgentError } from "./errors.js";
+import { applyEvalOverrides, EVAL_SESSION_SOURCE, isEvalSession } from "./evalSession.js";
 import { agentMemoryIssues } from "../memory/agentIssues.js";
 import { diffLines } from "./lineDiff.js";
 import { exportTurnsToOtlp } from "./otlpExport.js";
@@ -38,6 +39,8 @@ export class AgentService {
     environment;
     now;
     tails = new Map();
+    /** Overrides of open eval sessions. Memory only: eval sessions do not survive a Host restart. */
+    evalOverrides = new Map();
     /** Wakes a turn paused at an ask-first tool when its approval is decided. */
     approvalBroker = new ApprovalBroker();
     /** Owns every legal change of a turn, its session and its approval. */
@@ -311,6 +314,64 @@ export class AgentService {
             throw new AgentError("agent.revision_not_found");
         return found.definition;
     }
+    /** The pinned definition, with an eval session's overrides applied. Real sessions get it unchanged. */
+    async effectiveDefinition(projectRoot, session) {
+        const base = await this.definitionAt(projectRoot, session.agentId, session.revision);
+        return isEvalSession(session) ? applyEvalOverrides(base, this.evalOverrides.get(session.id) ?? {}) : base;
+    }
+    /** The overrides an eval session was opened with (sub-agent sessions inherit them), or undefined for a real session. */
+    evalOverridesOf(sessionId) {
+        return this.evalOverrides.get(sessionId);
+    }
+    /** Every eval session below this one (sub-agents and theirs). */
+    listChildSessions(sessionId) {
+        return this.store.listChildSessions(sessionId);
+    }
+    /** Delete eval sessions and everything below them. Refuses a session that is not an eval session. */
+    async deleteEvalSessions(projectRoot, sessionIds) {
+        const roots = sessionIds.map((sessionId) => this.sessionInProject(projectRoot, sessionId));
+        const refused = roots.find((session) => !isEvalSession(session));
+        if (refused)
+            throw new AgentError("agent.invalid", `Session ${refused.id} is not an eval session`);
+        const all = new Set(roots.map((session) => session.id));
+        for (const root of roots)
+            for (const child of this.store.listChildSessions(root.id))
+                all.add(child.id);
+        const ids = [...all];
+        this.store.deleteSessions(ids);
+        for (const sessionId of ids)
+            this.evalOverrides.delete(sessionId);
+        return ids;
+    }
+    /**
+     * Boot cleanup of eval sessions: those of the given (recovered) eval runs, and older root sessions no eval result
+     * references. Returns how many sessions were deleted, descendants included.
+     */
+    async sweepEvalSessions(input) {
+        const roots = new Map();
+        for (const session of this.store.listEvalRootSessions({ sourceRefs: input.runIds }))
+            roots.set(session.id, session);
+        const cutoff = new Date(this.clockMs() - input.olderThanMs).toISOString();
+        for (const session of this.store.listEvalRootSessions({ createdBefore: cutoff })) {
+            if (!roots.has(session.id) && !(await input.isReferenced(session.id)))
+                roots.set(session.id, session);
+        }
+        const all = new Set();
+        for (const root of roots.values()) {
+            all.add(root.id);
+            for (const child of this.store.listChildSessions(root.id))
+                all.add(child.id);
+        }
+        const ids = [...all];
+        this.store.deleteSessions(ids);
+        for (const sessionId of ids)
+            this.evalOverrides.delete(sessionId);
+        return ids.length;
+    }
+    /** Forget a finished eval session's in-memory overrides. The rows stay readable. */
+    forgetEvalSession(sessionId) {
+        this.evalOverrides.delete(sessionId);
+    }
     /* ---------- validation ---------- */
     async warningsFor(projectRoot, definition) {
         const warnings = [];
@@ -515,8 +576,9 @@ export class AgentService {
                     return false;
                 throw error;
             });
-            if (onDisk || (existing && !existing.archived))
-                throw new AgentError("agent.exists");
+            if (onDisk || (existing && !existing.archived)) {
+                throw new AgentError("agent.exists", `An agent with id "${definition.id}" already exists`);
+            }
             // A new agent always starts disabled (R1); enabling is its own revision.
             await this.writeRevision(projectRoot, { ...definition, enabled: false }, actor, "Created");
         });
@@ -636,10 +698,20 @@ export class AgentService {
     }
     /* ---------- sessions ---------- */
     async openSession(projectRoot, agentId, input) {
+        if (input.eval && input.source !== EVAL_SESSION_SOURCE)
+            throw new AgentError("agent.invalid", "Eval overrides need an eval session");
         return this.exclusive(projectRoot, async () => {
             await this.sync(projectRoot);
-            const { revision } = this.currentRevision(projectRoot, agentId);
-            if (!revision.definition.enabled)
+            const isEval = input.source === EVAL_SESSION_SOURCE;
+            const { revision: current } = this.currentRevision(projectRoot, agentId);
+            let revision = current;
+            if (input.eval?.revision !== undefined && input.eval.revision !== current.revision) {
+                const pinned = this.store.getRevision(agentProjectKey(projectRoot), agentId, input.eval.revision);
+                if (!pinned)
+                    throw new AgentError("agent.revision_not_found");
+                revision = pinned;
+            }
+            if (!isEval && !revision.definition.enabled)
                 throw new AgentError("agent.disabled");
             const now = this.iso();
             const session = {
@@ -656,6 +728,8 @@ export class AgentService {
                 updatedAt: now,
             };
             this.store.insertSession(agentProjectKey(projectRoot), session);
+            if (isEval)
+                this.evalOverrides.set(session.id, input.eval ?? {});
             return session;
         });
     }
@@ -663,8 +737,8 @@ export class AgentService {
     pendingApprovalFor(_projectRoot, sessionId) {
         return this.store.listApprovals(sessionId).find((approval) => approval.status === "pending")?.id ?? null;
     }
-    listSessionsForRef(projectRoot, agentId, source, sourceRef, limit) {
-        return this.store.listSessionsForRef(agentProjectKey(projectRoot), agentId, source, sourceRef, limit);
+    listSessionsForRef(projectRoot, agentId, source, sourceRef, limit, includeEval) {
+        return this.store.listSessionsForRef(agentProjectKey(projectRoot), agentId, source, sourceRef, limit, includeEval);
     }
     sessionInProject(projectRoot, sessionId) {
         const session = this.store.getSession(sessionId);
@@ -698,7 +772,7 @@ export class AgentService {
             const since = new Date(this.now().getTime() - RECENT_WINDOW_MS).toISOString();
             return {
                 ...this.store.listSessions(projectKey, agentId, query),
-                stats: this.store.sessionStats(projectKey, agentId, since),
+                stats: this.store.sessionStats(projectKey, agentId, since, query.includeEval),
             };
         });
     }
@@ -711,7 +785,7 @@ export class AgentService {
             const since = new Date(this.now().getTime() - RECENT_WINDOW_MS).toISOString();
             return {
                 ...this.store.listSessions(projectKey, agentId, query),
-                stats: this.store.sessionStats(projectKey, agentId, since),
+                stats: this.store.sessionStats(projectKey, agentId, since, query.includeEval),
             };
         });
     }
@@ -745,11 +819,11 @@ export class AgentService {
             await this.sync(projectRoot);
             const session = this.sessionInProject(projectRoot, sessionId);
             const { revision: live } = this.currentRevision(projectRoot, session.agentId);
-            if (!live.definition.enabled)
+            if (!live.definition.enabled && !isEvalSession(session))
                 throw new AgentError("agent.disabled");
             if (session.status === "running" || session.status === "waiting")
                 throw new AgentError("agent.session_busy");
-            const definition = await this.definitionAt(projectRoot, session.agentId, session.revision);
+            const definition = await this.effectiveDefinition(projectRoot, session);
             this.assertWithinLimits(definition, session);
             const now = this.iso();
             return this.store.transaction(() => {
@@ -930,9 +1004,9 @@ export class AgentService {
             this.expireApprovals();
             const session = this.sessionInProject(projectRoot, sessionId);
             const { revision: live } = this.currentRevision(projectRoot, session.agentId);
-            if (!live.definition.enabled)
+            if (!live.definition.enabled && !isEvalSession(session))
                 throw new AgentError("agent.disabled");
-            const definition = await this.definitionAt(projectRoot, session.agentId, session.revision);
+            const definition = await this.effectiveDefinition(projectRoot, session);
             if (!isToolGranted(definition, input.tool))
                 throw new AgentError("agent.tool_not_granted");
             if (!requiresAskFirst(definition, input.tool))
@@ -975,7 +1049,9 @@ export class AgentService {
         return this.exclusive(projectRoot, async () => {
             await this.sync(projectRoot);
             const session = this.sessionInProject(projectRoot, sessionId);
-            const definition = await this.definitionAt(projectRoot, session.agentId, session.revision);
+            if (isEvalSession(session))
+                throw new AgentError("agent.session_eval_readonly", "Eval sessions are read only");
+            const definition = await this.effectiveDefinition(projectRoot, session);
             if (!canApprove(definition, actor))
                 throw new AgentError("agent.approval_forbidden");
             const pending = this.store.getPendingApproval(sessionId);
@@ -997,9 +1073,9 @@ export class AgentService {
             return decided.approval;
         });
     }
-    async pendingApprovals(projectRoot) {
+    async pendingApprovals(projectRoot, options = {}) {
         this.expireApprovals();
-        return this.store.listPendingApprovals(agentProjectKey(projectRoot));
+        return this.store.listPendingApprovals(agentProjectKey(projectRoot), options.includeEval);
     }
     /* ---------- communications ---------- */
     async receive(projectRoot, message) {

package/dist/agents/sessions.d.ts

@@ -1,3 +1,5 @@
+import type { EvalGateRegistry } from "./evalGate.js";
+import { type EvalSessionOverrides } from "./evalSession.js";
 import type { OtlpSink } from "./otlpSink.js";
 import type { ConversationBackend } from "./runtime/types.js";
 import type { AgentService, AgentSessionDetail } from "./service.js";
@@ -11,6 +13,10 @@ export type SendTurnInput = {
     author?: string | null;
     /** Where a new session came from: console, cli, mcp, schedule, or a provider id. */
     source?: string;
+    /** Where a new session points to; defaults to the author. Eval sessions point at their eval run or parent session. */
+    sourceRef?: string | null;
+    /** Overrides for a new eval session (needs `source: "eval"`). */
+    eval?: EvalSessionOverrides;
     onDelta?: (text: string) => void;
     onSessionOpened?: (sessionId: string) => void;
     /** Retry this earlier, interrupted turn: its user message is reused, not asked again. */
@@ -20,6 +26,8 @@ export type ConversationOptions = {
     service: AgentService;
     backend: ConversationBackend;
     otlpSink?: OtlpSink | undefined;
+    /** Eval tool gates by session id. An eval session without one is denied every tool. */
+    evalGates?: EvalGateRegistry;
     logError?: (message: string) => void;
 };
 /** One turn: open (if needed) → record user message → model + tools → guardrails → record reply. */