stageflow 0.42.0 → 0.44.0

package/dist/runtime/sandboxDesk.js

@@ -37,16 +37,14 @@ export function buildSandboxDesk(input) {
             optional: false,
         });
     }
-    const grants = input.grantedPaths ?? [];
-    for (let index = 0; index < grants.length; index += 1) {
-        const hostPath = grants[index];
+    for (const grant of input.grants ?? []) {
         bindings.push({
             role: "grant",
-            hostPath,
-            containerPath: `${SANDBOX_MOUNT_PATH}/grants/${grantSegment(index, hostPath)}`,
-            shape: "mirror",
+            hostPath: grant.hostPath,
+            containerPath: grant.containerPath,
+            shape: grant.kind === "directory" ? "directory" : "file",
             copyIn: true,
-            copyOut: true,
+            copyOut: false,
             optional: false,
         });
     }
@@ -61,11 +59,6 @@ export function buildSandboxDesk(input) {
     });
     return { bindings };
 }
-function grantSegment(index, hostPath) {
-    const base = path.basename(hostPath).replace(/[^A-Za-z0-9_.-]/g, "_");
-    const safe = base.length > 0 && base !== "." && base !== ".." ? base : "path";
-    return `${index}-${safe}`;
-}
 async function pathExists(target) {
     try {
         await access(target);
@@ -85,6 +78,12 @@ export async function populateSandboxDesk(params) {
         if (binding.role === "checkout" || binding.shape === "mirror") {
             dirs.add(binding.containerPath);
         }
+        if (binding.role === "grant" && binding.shape === "file") {
+            dirs.add(path.posix.dirname(binding.containerPath));
+        }
+        if (binding.role === "grant" && binding.shape === "directory") {
+            dirs.add(binding.containerPath);
+        }
     }
     const made = await execInSandboxContainer({
         containerName: params.containerName,

package/dist/runtime/stageEnvironment.js

@@ -28,6 +28,7 @@ export const STAGE_ENV_ALLOWLIST = [
     "STAGEFLOW_CURSOR_EXTENSION",
     "STAGEFLOW_STAGE_CONTAINER_IMAGE",
     "STAGEFLOW_STAGE_CONTAINER_DOCKER_BIN",
+    "STAGEFLOW_STAGE_READONLY_DIR",
 ];
 export const PROVIDER_AND_CLOUD_NAMES = [
     "ANTHROPIC_API_KEY",

package/dist/runtime/stageRoots.d.ts

@@ -2,6 +2,14 @@ import type { RunMeta } from "../runstore/port.js";
 import type { StageAttemptContext } from "./stageAttemptContext.js";
 import type { TaskFile, TaskGitIdentity } from "../types/task.js";
 export type DerivedBindingKind = "repository" | "checkout" | "unbound";
+export type StageArtifactGrant = {
+    /** Run-relative path from the prior envelope. */
+    listedPath: string;
+    hostPath: string;
+    /** File or directory inside the sandbox, under /workspace/grants. */
+    containerPath: string;
+    kind: "file" | "directory";
+};
 export type StageRoots = {
     mode: "bound" | "unbound";
     cwd: string;
@@ -19,6 +27,10 @@ export type StageRoots = {
     containerName?: string;
     /** The docker binary the container above was started with (see STAGEFLOW_STAGE_CONTAINER_DOCKER_BIN). */
     containerDockerBin?: string;
+    /** Host folder bind-mounted read-only into the sandbox at this same path. */
+    readonlyDir?: string;
+    /** Prior artifacts mounted into the sandbox. Empty or omitted when none are granted. */
+    artifactGrants?: readonly StageArtifactGrant[];
 };
 export declare const STAGEFLOW_CHECKOUT = "STAGEFLOW_CHECKOUT";
 export declare const STAGEFLOW_RUN_WORKSPACE = "STAGEFLOW_RUN_WORKSPACE";

package/dist/runtime/stageSandbox.d.ts

@@ -1,4 +1,4 @@
-import { type StageRoots } from "./stageRoots.js";
+import { type StageArtifactGrant, type StageRoots } from "./stageRoots.js";
 export type StageSandbox = {
     roots: StageRoots;
     beforeVerify?: () => Promise<void>;
@@ -13,4 +13,5 @@ export declare function openStageSandbox(input: {
     attempt: number;
     attemptDir: string;
     checkoutRoot?: string;
+    grants?: readonly StageArtifactGrant[];
 }): Promise<StageSandbox>;

package/dist/runtime/stageSandbox.js

@@ -1,4 +1,4 @@
-import { resolveSandboxContainerOptions, startSandboxContainer, stopSandboxContainer, } from "./sandboxContainer.js";
+import { assertStageReadOnlyDirExists, resolveSandboxContainerOptions, stageReadOnlyDir, startSandboxContainer, stopSandboxContainer, } from "./sandboxContainer.js";
 import { buildSandboxDesk, populateSandboxDesk, syncSandboxDesk, } from "./sandboxDesk.js";
 import { withContainerName } from "./stageRoots.js";
 export async function openStageSandbox(input) {
@@ -6,18 +6,34 @@ export async function openStageSandbox(input) {
     if (!options) {
         return { roots: input.roots, close: async () => { } };
     }
+    let readOnlyDir;
+    try {
+        readOnlyDir = stageReadOnlyDir(input.env);
+        if (readOnlyDir !== undefined)
+            await assertStageReadOnlyDirExists(readOnlyDir);
+    }
+    catch (err) {
+        return {
+            roots: input.roots,
+            close: async () => { },
+            failure: err instanceof Error ? err.message : String(err),
+        };
+    }
     const started = await startSandboxContainer({
         image: options.image,
         dockerBin: options.dockerBin,
         runId: input.runId,
         stageId: input.stageId,
         attempt: input.attempt,
+        ...(readOnlyDir !== undefined ? { readOnlyDir } : {}),
     });
-    const roots = withContainerName(input.roots, started.containerName, options.dockerBin);
+    const roots = withContainerName(readOnlyDir !== undefined ? { ...input.roots, readonlyDir: readOnlyDir } : input.roots, started.containerName, options.dockerBin);
     const checkout = input.checkoutRoot?.trim();
+    const grants = input.grants ?? [];
     const desk = buildSandboxDesk({
         attemptDir: input.attemptDir,
         ...(checkout ? { checkoutRoot: checkout } : {}),
+        ...(grants.length > 0 ? { grants } : {}),
     });
     const session = {
         roots,

package/dist/runtime/stageWorker.js

@@ -16,6 +16,9 @@ import { runStage, isRunStageWaiting, } from "./stageRunner.js";
 import { openStageAttempt } from "./stageAttemptBootstrap.js";
 import { attemptContext } from "./stageAttemptContext.js";
 import { loadActiveFeedbackLoopContext } from "./feedbackLoopCoordinator.js";
+import { buildCompletedEnvelopesFromRun, resolvePriorEnvelope, } from "./envelopeRouting.js";
+import { assignment } from "./cloneSchedule.js";
+import { artifactGrantsFromPriors } from "./priorArtifactGrants.js";
 import { outcomeToWorkerResult, SF_STAGE_WORKER, STAGE_WORKER_EXIT, } from "./stageWorkerProtocol.js";
 export async function runStageWorker(input) {
     const store = createRunStore({ rootDir: globalStageflowHome() });
@@ -67,6 +70,19 @@ export async function runStageWorker(input) {
     const eventOptions = { attempt };
     let roots = withResolvedAuthPath(rootsForStageWorker(workspaceDir, input.stageId, stage.model, checkoutRoot, attemptCtx), input.rootDir);
     const unbindAgentDir = bindPiAgentDirEnv(roots.agentDir);
+    const completedEnvelopes = await buildCompletedEnvelopesFromRun(store, input.runId, undefined, dag);
+    const assigned = assignment(dag, input.stageId, definitionId, completedEnvelopes);
+    const priorResult = assigned ??
+        (await resolvePriorEnvelope({
+            dag,
+            stageId: input.stageId,
+            completedEnvelopes,
+            store,
+            runId: input.runId,
+        }));
+    const artifactGrants = priorResult.ok
+        ? await artifactGrantsFromPriors(workspaceDir, priorResult)
+        : [];
     const sandbox = await openStageSandbox({
         env: process.env,
         roots,
@@ -75,8 +91,12 @@ export async function runStageWorker(input) {
         attempt,
         attemptDir,
         ...(checkoutRoot !== undefined ? { checkoutRoot } : {}),
+        ...(artifactGrants.length > 0 ? { grants: artifactGrants } : {}),
     });
     roots = sandbox.roots;
+    if (artifactGrants.length > 0) {
+        roots = { ...roots, artifactGrants };
+    }
     const beforeVerify = sandbox.beforeVerify;
     let outcome;
     let thrown;

package/dist/server/agentAuthorRoutes.js

@@ -1,5 +1,5 @@
-import { authorSessionForApi, parseAgentAuthorDraft, runAgentAuthorTurn, undoAgentAuthorTurn, } from "../agents/authorChat.js";
-import { createAuthorSession, listAuthorDrafts, readAuthorSession, saveAuthorSession } from "../agents/authorSessionStore.js";
+import { authorSessionForApi, forgetAgentAuthorSession, parseAgentAuthorDraft, runAgentAuthorTurn, undoAgentAuthorTurn, } from "../agents/authorChat.js";
+import { createAuthorSession, deleteAuthorSession, listAuthorDrafts, readAuthorSession, saveAuthorSession, } from "../agents/authorSessionStore.js";
 import { parseWorkshopModel } from "../workshop/modelSettings.js";
 async function readBody(req) {
     const chunks = [];
@@ -46,13 +46,22 @@ export async function handleAgentAuthorRoutes(req, method, pathname, projectRoot
         json(res, 200, { drafts: listAuthorDrafts() });
         return true;
     }
-    if (sessionMatch && (method === "GET" || method === "PUT")) {
+    if (sessionMatch && (method === "GET" || method === "PUT" || method === "DELETE")) {
         const sessionId = decodeURIComponent(sessionMatch[1] ?? "");
         try {
             if (method === "GET") {
                 json(res, 200, authorSessionForApi(sessionId));
                 return true;
             }
+            if (method === "DELETE") {
+                forgetAgentAuthorSession(sessionId);
+                if (!deleteAuthorSession(sessionId)) {
+                    json(res, 404, { code: "agent.session_not_found" });
+                    return true;
+                }
+                json(res, 200, { removed: true });
+                return true;
+            }
             const body = await readBody(req);
             if (body.__tooLarge || body.__invalid) {
                 json(res, 400, { code: "agent.invalid" });

package/dist/server/bootstrap.d.ts

@@ -17,6 +17,7 @@ import { type RunChangeBus } from "../runtime/runChangeBus.js";
 import { type McpHttpHandler } from "../mcp/server.js";
 import { type HostConfig } from "../config/hostConfig.js";
 import { bootProviderConfig } from "../agent/bootProviderConfig.js";
+import type { OperatorAgentHost } from "../operatorAgent/types.js";
 import { type AgentHostContext } from "../agents/hostContext.js";
 import type { ConversationBackend } from "../agents/sessions.js";
 export declare const DEFAULT_GC_INTERVAL_MS: number;
@@ -78,6 +79,10 @@ export type StageflowHostBootstrap = {
     memories?: MemoryHost;
     /** Shared agent store, chat controller, and conversation backend for HTTP/MCP. */
     agentHost?: AgentHostContext;
+    /** Filled when the operator console host is created, so internal-agent evals can open a gated session. */
+    operatorHostSlot?: {
+        current?: OperatorAgentHost;
+    };
     email?: ReturnType<typeof emailHostFor> & {
         triggers: EmailTriggers;
         stop: () => Promise<void>;

package/dist/server/bootstrap.js

@@ -40,6 +40,8 @@ import { logger as rootLogger } from "../logging/logger.js";
 import { getModelCatalog } from "../models/catalog.js";
 import { createAgentCaseRunner } from "../evals/runner/agentCaseRunner.js";
 import { createEvalCaseRunner } from "../evals/runner/caseRunner.js";
+import { createInternalAgentCaseRunner } from "../evals/runner/internalAgentCaseRunner.js";
+import { describeInternalAgents, internalAgentsVisible } from "../operatorAgent/internalAgents.js";
 import { defaultLoadJudgePrices } from "../evals/engine/promptfoo/judgeServices.js";
 import { createAgentHostContext } from "../agents/hostContext.js";
 export const DEFAULT_GC_INTERVAL_MS = 60 * 60 * 1000;
@@ -268,17 +270,22 @@ export async function bootstrapStageflowHost(options) {
     await manager.reenqueuePersistedQueuedRuns();
     const evalLog = rootLogger.child({ component: "evals" });
     const evalStageRunner = createStageCaseRunner({ manager, store });
+    const operatorHostSlot = {};
     const evalAgentRunner = createAgentCaseRunner({
         host: () => agentHost,
         loadPrices: defaultLoadJudgePrices,
     });
-    const evalRunner = createEvalCaseRunner({ stage: evalStageRunner, agent: evalAgentRunner });
+    const evalInternalRunner = createInternalAgentCaseRunner({ host: () => operatorHostSlot.current });
+    const evalRunner = createEvalCaseRunner({ stage: evalStageRunner, agent: evalAgentRunner, internalAgent: evalInternalRunner });
     const evalTokens = new RunTokenRegistry();
     let evalCallbackBase = "";
     const evalRunManager = new EvalRunManager({
         store,
         stageRunner: evalRunner,
         agents: () => agentHost?.service,
+        internalAgents: () => operatorHostSlot.current && internalAgentsVisible()
+            ? describeInternalAgents(operatorHostSlot.current).map(({ id, title, playbook, tools }) => ({ id, title, playbook, tools }))
+            : [],
         engines: (name, engineOptions) => getEngine(name, name === EVAL_DEFAULT_ENGINE
             ? {
                 tokens: evalTokens,
@@ -400,6 +407,9 @@ export async function bootstrapStageflowHost(options) {
                 store,
                 agentDir,
                 projectRoot: rootDir,
+                channels,
+                memories: memoryHostFor(),
+                evalRunManager,
                 ...(options.providerAuthContext ? { providerAuthContext: options.providerAuthContext } : {}),
                 ...(providerBoot !== undefined ? { providerBoot } : {}),
             },
@@ -419,6 +429,8 @@ export async function bootstrapStageflowHost(options) {
         providerAuthContext: options.providerAuthContext,
         projectRoot: rootDir,
         evalRunManager,
+        channels,
+        memories: memoryHostFor(),
         ...(agentHost
             ? {
                 agentService: agentHost.service,
@@ -462,5 +474,6 @@ export async function bootstrapStageflowHost(options) {
         storeFilesystem,
         workspaceCatalog,
         ...(agentHost ? { agentHost } : {}),
+        operatorHostSlot,
     };
 }

package/dist/server/evalRoutes.js

@@ -141,7 +141,8 @@ function agentsOf(c) {
 }
 function agentsInput(c) {
     const agents = agentsOf(c);
-    return agents ? { agents } : {};
+    const internalAgents = c.evalRunManager.visibleInternalAgents();
+    return { ...(agents ? { agents } : {}), ...(internalAgents.length > 0 ? { internalAgents } : {}) };
 }
 function engineCheck(c) {
     engineCheckStatus(c.engineStatus());
@@ -254,11 +255,30 @@ function parseDefinitionOrYaml(body) {
         throw bad(`"definition" must be an object`);
     return { definition: body.definition };
 }
+function validateEvalId(input) {
+    if (isRecord(input.definition) && typeof input.definition.id === "string")
+        return input.definition.id;
+    if (typeof input.yaml !== "string")
+        return undefined;
+    const match = /^id:\s*["']?([A-Za-z0-9][A-Za-z0-9._-]{0,63})["']?\s*$/m.exec(input.yaml);
+    return match?.[1];
+}
+async function existingEvalFile(c, wire, id) {
+    try {
+        const located = await evalRootFor(c, wire, id);
+        return { projectRoot: located.projectRoot, absPath: located.ref.absPath };
+    }
+    catch (err) {
+        if (err instanceof EvalApiError && err.status === 404)
+            return undefined;
+        throw err;
+    }
+}
 async function handleEvalValidate(c) {
     const body = await readBody(c);
     const input = parseDefinitionOrYaml(body);
-    const projectRoot = await projectRootFor(c, wireFromBody(body));
-    const manifest = await manifestForWrite(projectRoot);
+    const wire = wireFromBody(body);
+    let projectRoot = await projectRootFor(c, wire);
     const suppliedPath = optString(body, "path");
     const datasetCases = optDatasetCases(body);
     let evalAbs;
@@ -267,10 +287,18 @@ async function handleEvalValidate(c) {
         assertInsideProject(projectRoot, evalAbs, "eval path");
     }
     else {
-        const rawId = isRecord(input.definition) ? input.definition.id : undefined;
-        const dir = await resolveWriteDir(projectRoot, manifest, "evals");
-        const fileName = typeof rawId === "string" && ID_RE.test(rawId) ? `${rawId}.eval.yaml` : "new.eval.yaml";
-        evalAbs = path.join(dir.absDir, fileName);
+        const rawId = validateEvalId(input);
+        const located = rawId !== undefined && ID_RE.test(rawId) ? await existingEvalFile(c, wire, rawId) : undefined;
+        if (located) {
+            projectRoot = located.projectRoot;
+            evalAbs = located.absPath;
+        }
+        else {
+            const manifest = await manifestForWrite(projectRoot);
+            const dir = await resolveWriteDir(projectRoot, manifest, "evals");
+            const fileName = rawId !== undefined && ID_RE.test(rawId) ? `${rawId}.eval.yaml` : "new.eval.yaml";
+            evalAbs = path.join(dir.absDir, fileName);
+        }
     }
     let derived;
     if (input.yaml !== undefined) {
@@ -955,7 +983,7 @@ async function datasetDetailFor(c, projectRoot, id, absPath, evalId, query) {
     let inputSchema;
     let agent;
     if (useEval !== undefined) {
-        if (useEval.loaded.file.target.kind === "agent") {
+        if (useEval.loaded.file.target.kind === "agent" || useEval.loaded.file.target.kind === "internal_agent") {
             agent = { mode: resolveConversation(useEval.loaded.file.conversation).mode };
         }
         else {
@@ -1014,7 +1042,8 @@ async function conversationModeOf(c, body) {
         return undefined;
     const { projectRoot, ref } = await evalRootFor(c, wireFromBody(body), evalId);
     const outcome = await loadEvalOutcome(ref.absPath, projectRoot);
-    return outcome.ok && outcome.value.file.target.kind === "agent"
+    const kind = outcome.ok ? outcome.value.file.target.kind : undefined;
+    return outcome.ok && (kind === "agent" || kind === "internal_agent")
         ? resolveConversation(outcome.value.file.conversation).mode
         : undefined;
 }

package/dist/server/guideRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OperatorAgentHost } from "../operatorAgent/index.js";
+type Json = (res: ServerResponse, status: number, body: unknown) => void;
+export declare function handleGuideRoutes(req: IncomingMessage, method: string, pathname: string, host: OperatorAgentHost, res: ServerResponse, json: Json): Promise<boolean>;
+export {};

package/dist/server/guideRoutes.js

@@ -0,0 +1,166 @@
+import { abortGuideTurn, GuideError, guideAgentInfo, isGuideThreadRunning, streamGuideTurn, } from "../guide/chat.js";
+import { createGuideThread, listGuideThreads, readGuideThread, setGuideThreadModel, } from "../guide/threadStore.js";
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        size += buffer.length;
+        if (size > 1_500_000)
+            return { __tooLarge: true };
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : { __invalid: true };
+    }
+    catch {
+        return { __invalid: true };
+    }
+}
+function threadSummary(record) {
+    return { id: record.id, title: record.title, updatedAt: record.updatedAt };
+}
+function canWrite(res) {
+    return !res.writableEnded && !res.destroyed;
+}
+export async function handleGuideRoutes(req, method, pathname, host, res, json) {
+    const root = pathname === "/api/guide";
+    const threads = pathname === "/api/guide/threads";
+    const threadMatch = /^\/api\/guide\/threads\/([^/]+)$/.exec(pathname);
+    const messageMatch = /^\/api\/guide\/threads\/([^/]+)\/messages$/.exec(pathname);
+    const stopMatch = /^\/api\/guide\/threads\/([^/]+)\/stop$/.exec(pathname);
+    if (!root && !threads && !threadMatch && !messageMatch && !stopMatch)
+        return false;
+    if (root && method === "GET") {
+        json(res, 200, { agent: guideAgentInfo(host) });
+        return true;
+    }
+    if (threads && method === "GET") {
+        json(res, 200, {
+            threads: listGuideThreads().map((thread) => ({
+                ...thread,
+                status: isGuideThreadRunning(thread.id) ? "running" : "open",
+            })),
+        });
+        return true;
+    }
+    if (threads && method === "POST") {
+        const record = createGuideThread();
+        json(res, 201, { thread: threadSummary(record) });
+        return true;
+    }
+    if (stopMatch && method === "POST") {
+        const threadId = decodeURIComponent(stopMatch[1] ?? "");
+        const record = readGuideThread(threadId);
+        if (!record) {
+            json(res, 404, { code: "guide.not_found", message: "" });
+            return true;
+        }
+        json(res, 200, { ok: true, stopped: abortGuideTurn(threadId) });
+        return true;
+    }
+    if (threadMatch && method === "GET") {
+        const threadId = decodeURIComponent(threadMatch[1] ?? "");
+        const record = readGuideThread(threadId);
+        if (!record) {
+            json(res, 404, { code: "guide.not_found", message: "" });
+            return true;
+        }
+        json(res, 200, {
+            thread: threadSummary(record),
+            status: isGuideThreadRunning(record.id) ? "running" : "open",
+            messages: record.messages,
+            model: record.model ?? null,
+        });
+        return true;
+    }
+    if (threadMatch && method === "PATCH") {
+        const threadId = decodeURIComponent(threadMatch[1] ?? "");
+        const body = await readBody(req);
+        if (body.__tooLarge || body.__invalid) {
+            json(res, 400, { code: "guide.invalid", message: "" });
+            return true;
+        }
+        let record = readGuideThread(threadId);
+        if (!record) {
+            json(res, 404, { code: "guide.not_found", message: "" });
+            return true;
+        }
+        if ("model" in body) {
+            if (typeof body.model === "string") {
+                const next = setGuideThreadModel(threadId, body.model.trim() || null);
+                if (!next) {
+                    json(res, 404, { code: "guide.not_found", message: "" });
+                    return true;
+                }
+                record = next;
+            }
+            else if (body.model === null) {
+                const next = setGuideThreadModel(threadId, null);
+                if (!next) {
+                    json(res, 404, { code: "guide.not_found", message: "" });
+                    return true;
+                }
+                record = next;
+            }
+            else {
+                json(res, 400, { code: "guide.invalid", message: "" });
+                return true;
+            }
+        }
+        json(res, 200, { thread: threadSummary(record), model: record.model ?? null });
+        return true;
+    }
+    if (messageMatch && method === "POST") {
+        const threadId = decodeURIComponent(messageMatch[1] ?? "");
+        const body = await readBody(req);
+        if (body.__tooLarge || body.__invalid) {
+            json(res, 400, { code: "guide.invalid", message: "" });
+            return true;
+        }
+        const text = typeof body.text === "string" ? body.text : "";
+        let started = false;
+        try {
+            for await (const frame of streamGuideTurn({
+                host,
+                threadId,
+                text,
+                attachments: body.attachments,
+                model: typeof body.model === "string" ? body.model : undefined,
+            })) {
+                if (!canWrite(res))
+                    continue;
+                if (!started) {
+                    started = true;
+                    res.writeHead(200, {
+                        "Content-Type": "application/x-ndjson; charset=utf-8",
+                        "Cache-Control": "no-store",
+                    });
+                }
+                res.write(`${JSON.stringify(frame)}\n`);
+            }
+        }
+        catch (err) {
+            const code = err instanceof GuideError ? err.code : "guide.failed";
+            const status = err instanceof GuideError ? err.status : 500;
+            if (!started && canWrite(res))
+                json(res, status, { code, message: "" });
+            else if (started && canWrite(res))
+                res.write(`${JSON.stringify({ type: "error", code, message: "" })}\n`);
+        }
+        finally {
+            if (!res.headersSent && canWrite(res))
+                json(res, 200, { code: "guide.failed", message: "" });
+            else if (canWrite(res))
+                res.end();
+        }
+        return true;
+    }
+    json(res, 405, { code: "guide.invalid", message: "" });
+    return true;
+}

package/dist/server/http.d.ts

@@ -1,6 +1,8 @@
 import type { StagePort } from "../agent/port.js";
 import { type ProviderAuthContext } from "../agent/providerAuth.js";
+import type { ChannelService } from "../channels/service.js";
 import type { EvalRunManager } from "../evals/manager.js";
+import type { MemoryHost } from "../memory/host.js";
 import { type LiveViewRoutesOptions } from "./liveViewRoutes.js";
 import { WorkshopChatSessionRegistry } from "../workshop/chatTurn.js";
 import { type AgentPort } from "../operatorAgent/index.js";
@@ -70,9 +72,17 @@ export type OperatorRouteDeps = {
     agentConversationBackend?: ConversationBackend;
     /** Shared with MCP when set by bootstrap. */
     agentHost?: AgentHostContext;
+    /** Bootstrap fills this once the operator host exists, so evals can run against it. */
+    operatorHostSlot?: {
+        current?: import("../operatorAgent/types.js").OperatorAgentHost;
+    };
     evalRunManager?: EvalRunManager;
     /** Wired by the eval manager; until then the internal eval callback answers 404. */
     evalServices?: EvalServices;
+    /** Host connections. Guide and MCP use the same service the console does. */
+    channels?: ChannelService;
+    /** Host memories. Guide and MCP use the same host the console does. */
+    memories?: MemoryHost;
 };
 /**
  * The full operator-console route surface: REST API (runs, stages,

package/dist/server/http.js

@@ -8,6 +8,7 @@ import { mapProviderAuthError } from "../agent/providerInspect.js";
 import { handleProviderRoutes } from "./providerRoutes.js";
 import { handleProjectMcpRoutes } from "./projectMcpRoutes.js";
 import { handleTriggerRoutes } from "./triggerRoutes.js";
+import { guideWriteRoot } from "../guide/writeRoot.js";
 import { handleEvalRoutes } from "./evalRoutes.js";
 import { defaultLoadJudgePrices } from "../evals/engine/promptfoo/judgeServices.js";
 import { engineStatus as promptfooEngineStatus } from "../evals/engine/promptfoo/status.js";
@@ -62,6 +63,8 @@ import { buildModelsResponse } from "../models/response.js";
 import { createAgentHostContext } from "../agents/hostContext.js";
 import { AgentScheduleSource, agentScheduleTickIntervalMsFromEnv, } from "../agents/scheduleSource.js";
 import { handleAgentAuthorRoutes } from "./agentAuthorRoutes.js";
+import { handleGuideRoutes } from "./guideRoutes.js";
+import { handleInternalAgentRoutes } from "./internalAgentRoutes.js";
 import { handleAgentRoutes } from "./agentRoutes.js";
 import { handleChannelRoutes } from "./channelRoutes.js";
 import { handleEvalInternalRoutes, isEvalInternalPath } from "./evalInternalRoutes.js";
@@ -217,7 +220,27 @@ export function createOperatorRoutes(deps) {
         resolveAgentPort({
             cwd,
             projectRoot: cwd,
+            guideDeps: {
+                manager,
+                store,
+                cwd,
+                agentDir,
+                projectRoot: guideWriteRoot(rootDir),
+                ...(providerAuthContext ? { providerAuthContext } : {}),
+                ...(deps.evalRunManager ? { evalRunManager: deps.evalRunManager } : {}),
+                ...(deps.channels ? { channels: deps.channels } : {}),
+                ...(deps.memories ? { memories: deps.memories } : {}),
+                ...(agentHost
+                    ? {
+                        agentService: agentHost.service,
+                        agentChat: agentHost.chat,
+                        agentConversationBackend: agentHost.backend,
+                    }
+                    : {}),
+            },
         });
+    if (deps.operatorHostSlot)
+        deps.operatorHostSlot.current = operatorHost;
     const workshopChatRegistry = deps.workshopChatRegistry ?? new WorkshopChatSessionRegistry(operatorHost);
     const workshopSessionStoreRoot = () => resolveWorkshopSessionStoreRoot();
     const workshopBuildStoreRoot = () => resolveWorkshopBuildStoreRoot();
@@ -263,6 +286,12 @@ export function createOperatorRoutes(deps) {
                     if (await handleAgentAuthorRoutes(req, method, pathname, cwd, operatorHost, res, json))
                         return true;
                 }
+                if (pathname === "/api/guide" || pathname.startsWith("/api/guide/")) {
+                    if (await handleGuideRoutes(req, method, pathname, operatorHost, res, json))
+                        return true;
+                }
+                if (handleInternalAgentRoutes(method, pathname, operatorHost, res, json))
+                    return true;
                 if (PublicWebChat.owns(pathname)) {
                     if (!agentHost) {
                         json(res, 503, { code: "web_chat.unavailable" });
@@ -1064,7 +1093,9 @@ export function createOperatorRoutes(deps) {
                     await readJsonBody(req);
                     const runId = decodeURIComponent(retryMatch[1] ?? "");
                     const stageId = decodeURIComponent(retryMatch[2] ?? "");
-                    const result = await manager.retryStage(runId, stageId);
+                    const result = await manager.retryStage(runId, stageId, {
+                        awaitRoot: false,
+                    });
                     if (!result.ok) {
                         json(res, result.status ?? 500, mapRetryStageFailure(result));
                         return true;
@@ -3178,8 +3209,11 @@ export async function startUiServer(options) {
                 ? { workshopOperatorHost: options.workshopOperatorHost }
                 : {}),
             ...(boot.agentHost ? { agentHost: boot.agentHost } : {}),
+            ...(boot.operatorHostSlot ? { operatorHostSlot: boot.operatorHostSlot } : {}),
             ...(boot.evalRunManager ? { evalRunManager: boot.evalRunManager } : {}),
             ...(boot.evalServices ? { evalServices: boot.evalServices } : {}),
+            ...(boot.channels ? { channels: boot.channels } : {}),
+            ...(boot.memories ? { memories: boot.memories } : {}),
             ...(options.agentConversationBackend
                 ? { agentConversationBackend: options.agentConversationBackend }
                 : {}),

package/dist/server/internalAgentRoutes.d.ts

@@ -0,0 +1,6 @@
+import type { ServerResponse } from "node:http";
+import type { OperatorAgentHost } from "../operatorAgent/index.js";
+type Json = (res: ServerResponse, status: number, body: unknown) => void;
+export declare const INTERNAL_AGENTS_PATH = "/api/internal-agents";
+export declare function handleInternalAgentRoutes(method: string, pathname: string, host: OperatorAgentHost, res: ServerResponse, json: Json, env?: NodeJS.ProcessEnv): boolean;
+export {};