@agentplate/cli 1.2.0 → 1.4.0

package/CHANGELOG.md

@@ -4,6 +4,49 @@ All notable changes to Agentplate are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project aims to adhere to
 [Semantic Versioning](https://semver.org/).
 
+## [1.4.0] — 2026-06-02
+
+### Added
+
+- **Full purge of reaped agents** (`agentplate reap --purge`, `agentplate stop
+  <agent> --purge`) — beyond stopping an agent and removing its worktree, purge
+  erases every trace it left behind: mail, events, queued merges, the on-disk
+  `.agentplate/agents/<name>/` state dir, the task spec (only once no sibling
+  session still references it), and the session row itself. A `PurgeReport` records
+  what was removed.
+- **`agents.purgeOnReap`** (default `false`) — when set, the `agentplate serve`
+  idle-reaper loop purges idle agents automatically (not just marks them stopped).
+  Surfaced as a gated toggle in `agentplate setup`.
+- **Store deletion APIs** backing the purge: `SessionStore.deleteSession`,
+  `EventStore.deleteByAgent`, and `MergeQueue.deleteByAgent`.
+
+### Changed
+
+- Plain `reap` / `serve` behavior is unchanged — reaping still keeps records for
+  history by default. Full erasure is strictly opt-in via `--purge` / `purgeOnReap`.
+
+## [1.3.0] — 2026-06-02
+
+### Added
+
+- **`agentplate watch`** — the mail pump that makes warm-start automatic: it
+  advances every **idle** agent with unread mail to its next (resumed) turn,
+  driving eligible agents concurrently up to `agents.maxConcurrent`. Modes:
+  `--once`, `--until-idle`, or loop until Ctrl-C.
+- **Hard per-turn timeout** (`agents.turnTimeoutMinutes`, 0 = off) — kills a turn
+  that runs past the cap even while still streaming (idle reaping only catches
+  inactivity).
+- **Per-capability runtime** — `runtime.capabilities[capability]` now selects the
+  runtime adapter per role (previously defined but unused).
+- **Speed shortcuts** — `agents.skipScout` / `skipReview` (surfaced as lead overlay
+  constraints) and `agents.skipGates` / `skipSkills` (honored on the turn path).
+- **Wizard** — a gated "advanced limits" step (concurrency, turn-timeout, skips).
+
+### Changed
+
+- The turn path is shared via `driveTurn` / `driveAgentTurn`, used by `sling`
+  (turn 1), `agentplate turn` (single follow-up), and `agentplate watch`.
+
 ## [1.2.0] — 2026-06-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentplate/cli",
-	"version": "1.2.0",
+	"version": "1.4.0",
 	"publishConfig": {
 		"access": "public"
 	},

package/src/agents/drive.ts

@@ -12,12 +12,15 @@
  * (resumed when `resumeSessionId` is given) — there is no long-lived agent.
  */
 
+import { existsSync } from "node:fs";
 import type { EventStore } from "../events/store.ts";
 import { runQualityGates } from "../insights/quality-gates.ts";
 import type { MailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
 import { maybeAutoMerge } from "../merge/auto.ts";
-import { mailDbPath } from "../paths.ts";
+import { mailDbPath, manifestFilePath } from "../paths.ts";
+import { getRuntime, runtimeNameForCapability } from "../runtimes/registry.ts";
+import { resolveModel } from "../runtimes/resolve.ts";
 import type { AgentRuntime } from "../runtimes/types.ts";
 import type { SessionStore } from "../sessions/store.ts";
 import { runSkillFeedbackAndDistill } from "../skills/lifecycle.ts";
@@ -30,6 +33,7 @@ import type {
 	SessionState,
 } from "../types.ts";
 import { updateIdentity } from "./identity.ts";
+import { buildDefaultManifest, getDefinition, loadManifest } from "./manifest.ts";
 import { runTurn } from "./turn-runner.ts";
 
 /** Terminal mail types whose presence marks a capability's work complete. */
@@ -106,6 +110,8 @@ export async function driveTurn(ctx: DriveTurnCtx): Promise<DriveTurnResult> {
 		prompt: ctx.prompt,
 		env: model.env,
 		resumeSessionId: ctx.resumeSessionId,
+		timeoutMs:
+			config.agents.turnTimeoutMinutes > 0 ? config.agents.turnTimeoutMinutes * 60_000 : undefined,
 		onEvent: (event) => {
 			if (event.error || event.type === "error") sawError = true;
 			// Prefer the error message (so a failed agent's reason is visible in the
@@ -123,6 +129,17 @@ export async function driveTurn(ctx: DriveTurnCtx): Promise<DriveTurnResult> {
 	});
 	if (turn.runtimeSessionId) store.setRuntimeSessionId(sessionId, turn.runtimeSessionId);
 
+	// Record a clear reason when the wall-clock cap killed the turn.
+	if (turn.timedOut) {
+		events.record({
+			agentName: name,
+			runId,
+			type: "error",
+			tool: null,
+			detail: `Turn killed: exceeded agents.turnTimeoutMinutes (${config.agents.turnTimeoutMinutes}m).`,
+		});
+	}
+
 	// A non-zero exit with no error event means the runtime failed via stderr;
 	// record it so the failure reason is visible instead of a blank "failed".
 	if (turn.exitCode !== 0 && !sawError) {
@@ -147,15 +164,19 @@ export async function driveTurn(ctx: DriveTurnCtx): Promise<DriveTurnResult> {
 	});
 
 	// Quality gates run once when EITHER the self-improving loop or auto-merge
-	// needs them; the outcome feeds both. Best-effort — never fails the turn.
+	// needs them (and gates aren't skipped); the outcome feeds both. Best-effort.
+	const runSkills = config.skills.enabled && !config.agents.skipSkills;
 	const autoMergeWants =
 		config.merge.autoMerge !== "off" && capability !== "scout" && capability !== "merger";
+	const wantGates = !config.agents.skipGates && (runSkills || autoMergeWants);
 	let gateStatus: OutcomeStatus | null = null;
-	if (finalState === "completed" && (config.skills.enabled || autoMergeWants)) {
+	if (finalState === "completed" && (wantGates || runSkills)) {
 		try {
-			const gateOutcome = await runQualityGates(config.project.qualityGates ?? [], worktreePath);
-			gateStatus = gateOutcome?.status ?? null;
-			if (config.skills.enabled) {
+			if (wantGates) {
+				const gateOutcome = await runQualityGates(config.project.qualityGates ?? [], worktreePath);
+				gateStatus = gateOutcome?.status ?? null;
+			}
+			if (runSkills) {
 				await runSkillFeedbackAndDistill({
 					root,
 					agentName: name,
@@ -198,3 +219,52 @@ export async function driveTurn(ctx: DriveTurnCtx): Promise<DriveTurnResult> {
 
 	return { finalState, exitCode: turn.exitCode, gateStatus };
 }
+
+export interface DriveAgentTurnCtx {
+	root: string;
+	config: AgentplateConfig;
+	session: AgentSession;
+	store: SessionStore;
+	events: EventStore;
+	mail: MailClient;
+}
+
+/**
+ * Run the next (resumed) turn for an existing session: resolve its runtime + model
+ * + manifest def, inject its unread mail as the prompt, and {@link driveTurn} with
+ * the stored `runtimeSessionId` (warm start). Shared by `agentplate turn` (single)
+ * and `agentplate watch` (the mail pump). Assumes the caller has already decided
+ * the session is drivable.
+ */
+export async function driveAgentTurn(ctx: DriveAgentTurnCtx): Promise<DriveTurnResult> {
+	const { root, config, session } = ctx;
+	const manifestPath = manifestFilePath(root);
+	const manifest = existsSync(manifestPath) ? loadManifest(manifestPath) : buildDefaultManifest();
+	const def = getDefinition(manifest, session.capability);
+	const runtime = getRuntime(
+		runtimeNameForCapability(config.runtime, session.capability),
+		config.runtime.default,
+	);
+	const model = resolveModel(config, root, def.model, session.capability);
+
+	// The turn's user text is the agent's unread mail (a child's reply / operator
+	// direction); fall back to a continue nudge. checkInject marks it read.
+	const injected = ctx.mail.checkInject(session.agentName);
+	const prompt =
+		injected.trim().length > 0
+			? injected
+			: "Continue your task. If it is complete, send your terminal mail.";
+
+	return driveTurn({
+		root,
+		config,
+		runtime,
+		store: ctx.store,
+		events: ctx.events,
+		mail: ctx.mail,
+		session,
+		model,
+		prompt,
+		resumeSessionId: session.runtimeSessionId ?? undefined,
+	});
+}

package/src/agents/turn-runner.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Tests for runTurn — focused on the hard wall-clock cap. Real subprocesses via
+ * the mock runtime (a `bash -lc` snippet), so we exercise true kill behavior.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MockRuntime } from "../runtimes/mock.ts";
+import { runTurn } from "./turn-runner.ts";
+
+let cwd: string;
+const runtime = new MockRuntime();
+
+beforeEach(() => {
+	cwd = mkdtempSync(join(tmpdir(), "agentplate-turnrunner-"));
+});
+afterEach(() => {
+	rmSync(cwd, { recursive: true, force: true });
+	process.env.AGENTPLATE_MOCK_CMD = undefined;
+});
+
+describe("runTurn — turn timeout", () => {
+	test("kills a turn that exceeds timeoutMs and flags timedOut", async () => {
+		process.env.AGENTPLATE_MOCK_CMD = "sleep 10"; // would hang well past the cap
+		const started = performance.now();
+		const result = await runTurn({
+			runtime,
+			worktreePath: cwd,
+			model: "m",
+			prompt: "",
+			timeoutMs: 200,
+		});
+		const elapsed = performance.now() - started;
+
+		expect(result.timedOut).toBe(true);
+		expect(result.exitCode).not.toBe(0); // killed → non-zero
+		expect(elapsed).toBeLessThan(3000); // resolved at the cap, not after 10s
+	});
+
+	test("does not flag timedOut when the turn finishes within the cap", async () => {
+		process.env.AGENTPLATE_MOCK_CMD = "true"; // instant exit 0
+		const result = await runTurn({
+			runtime,
+			worktreePath: cwd,
+			model: "m",
+			prompt: "",
+			timeoutMs: 5000,
+		});
+		expect(result.timedOut).toBe(false);
+		expect(result.exitCode).toBe(0);
+	});
+
+	test("no cap when timeoutMs is omitted/zero", async () => {
+		process.env.AGENTPLATE_MOCK_CMD = "true";
+		const result = await runTurn({
+			runtime,
+			worktreePath: cwd,
+			model: "m",
+			prompt: "",
+			timeoutMs: 0,
+		});
+		expect(result.timedOut).toBe(false);
+		expect(result.exitCode).toBe(0);
+	});
+});

package/src/agents/turn-runner.ts

@@ -23,6 +23,8 @@ export interface RunTurnOptions {
 	env?: Record<string, string>;
 	/** Prior runtime session id, to resume across turns. */
 	resumeSessionId?: string;
+	/** Hard wall-clock cap in ms; the child is killed past it. 0/undefined = none. */
+	timeoutMs?: number;
 	/** Called for each parsed event (e.g. to record tool calls). */
 	onEvent?: (event: AgentEvent) => void;
 }
@@ -33,6 +35,8 @@ export interface TurnResult {
 	runtimeSessionId: string | null;
 	/** Captured stderr (already bounded by the child). */
 	stderr: string;
+	/** True if the turn was killed by the wall-clock cap. */
+	timedOut: boolean;
 }
 
 /** Run a single headless turn and resolve when the child process exits. */
@@ -59,6 +63,18 @@ export async function runTurn(opts: RunTurnOptions): Promise<TurnResult> {
 		stdin: "ignore",
 	});
 
+	// Hard wall-clock cap: kill a turn that runs past the limit even if it keeps
+	// streaming (idle reaping only catches inactivity). Closing the child's pipes
+	// ends the drain/parse loops below, so the turn resolves with a non-zero exit.
+	let timedOut = false;
+	const timer =
+		opts.timeoutMs && opts.timeoutMs > 0
+			? setTimeout(() => {
+					timedOut = true;
+					proc.kill(); // SIGTERM
+				}, opts.timeoutMs)
+			: null;
+
 	// Read stderr concurrently so a full pipe buffer can't deadlock the child.
 	const stderrPromise = new Response(proc.stderr).text();
 
@@ -75,5 +91,6 @@ export async function runTurn(opts: RunTurnOptions): Promise<TurnResult> {
 
 	const stderr = await stderrPromise;
 	const exitCode = await proc.exited;
-	return { exitCode, runtimeSessionId, stderr };
+	if (timer) clearTimeout(timer);
+	return { exitCode, runtimeSessionId, stderr, timedOut };
 }

package/src/commands/reap.ts

@@ -6,6 +6,11 @@
  * live process, and removes its worktree + branch. The coordinator is never
  * reaped. Run it manually or on a cron; `agentplate serve` also reaps on its own
  * loop. Use `--dry-run` to preview and `--keep-worktrees` to leave worktrees.
+ *
+ * `--purge` goes further than a normal reap: it erases every trace of each reaped
+ * agent — mail, events, queued merges, the on-disk `.agentplate/agents/<name>/`
+ * state dir, and the session row itself — so the workspace is fully cleared. The
+ * plain reap keeps those records for history; purge is the opt-in clean slate.
  */
 
 import { Command } from "commander";
@@ -22,11 +27,21 @@ export function createReapCommand(): Command {
 		.description("Terminate agents idle past the timeout (stop + kill + remove worktree)")
 		.option("--minutes <n>", "idle timeout in minutes (default: config.agents.idleTimeoutMinutes)")
 		.option("--keep-worktrees", "mark stopped + kill process but keep worktrees/branches")
+		.option(
+			"--purge",
+			"fully erase each reaped agent (mail, events, merges, state dir, session row)",
+		)
 		.option("--dry-run", "list which agents would be reaped without changing anything")
 		.option("--json", "output JSON")
 		.action(
 			async (
-				opts: { minutes?: string; keepWorktrees?: boolean; dryRun?: boolean; json?: boolean },
+				opts: {
+					minutes?: string;
+					keepWorktrees?: boolean;
+					purge?: boolean;
+					dryRun?: boolean;
+					json?: boolean;
+				},
 				command: Command,
 			) => {
 				const useJson = command.optsWithGlobals().json === true;
@@ -51,11 +66,12 @@ export function createReapCommand(): Command {
 							now: Date.now(),
 						}).map((s) => ({ agent: s.agentName, capability: s.capability, state: s.state }));
 						if (useJson) {
-							jsonOutput({ dryRun: true, minutes, candidates });
+							jsonOutput({ dryRun: true, minutes, purge: opts.purge === true, candidates });
 						} else if (candidates.length === 0) {
 							printInfo(`No agents idle longer than ${minutes}m.`);
 						} else {
-							printInfo(`Would reap ${candidates.length} agent(s) idle >${minutes}m:`);
+							const how = opts.purge ? "reap + purge" : "reap";
+							printInfo(`Would ${how} ${candidates.length} agent(s) idle >${minutes}m:`);
 							for (const c of candidates) {
 								process.stdout.write(`  ${c.agent} ${muted(`(${c.capability}, ${c.state})`)}\n`);
 							}
@@ -66,17 +82,24 @@ export function createReapCommand(): Command {
 					const reaped = await reapIdleSessions(store, root, {
 						idleMs,
 						removeWorktrees: opts.keepWorktrees !== true,
+						purge: opts.purge === true,
 					});
 
 					if (useJson) {
-						jsonOutput({ minutes, reapedCount: reaped.length, reaped });
+						jsonOutput({ minutes, purge: opts.purge === true, reapedCount: reaped.length, reaped });
 					} else if (reaped.length === 0) {
 						printInfo(`No agents idle longer than ${minutes}m.`);
 					} else {
-						printSuccess(`Reaped ${reaped.length} idle agent(s) (>${minutes}m):`);
+						const verb = opts.purge ? "Reaped + purged" : "Reaped";
+						printSuccess(`${verb} ${reaped.length} idle agent(s) (>${minutes}m):`);
 						for (const r of reaped) {
 							const wt = r.worktreeRemoved ? "worktree removed" : "worktree kept";
-							process.stdout.write(`  ${r.agentName} ${muted(`(${r.capability}, ${wt})`)}\n`);
+							const extra = r.purged
+								? `, purged ${r.purged.mailDeleted} mail/${r.purged.eventsDeleted} events/${r.purged.mergeDeleted} merges`
+								: "";
+							process.stdout.write(
+								`  ${r.agentName} ${muted(`(${r.capability}, ${wt}${extra})`)}\n`,
+							);
 						}
 					}
 				} finally {

package/src/commands/sling.ts

@@ -31,7 +31,7 @@ import {
 	packageAgentDefPath,
 	sessionsDbPath,
 } from "../paths.ts";
-import { getRuntime } from "../runtimes/registry.ts";
+import { getRuntime, runtimeNameForCapability } from "../runtimes/registry.ts";
 import { resolveModel } from "../runtimes/resolve.ts";
 import { createSessionStore } from "../sessions/store.ts";
 import { retrieveSkillsForSpawn } from "../skills/lifecycle.ts";
@@ -159,7 +159,18 @@ export function createSlingCommand(): Command {
 				});
 
 				// 3. Overlay (base definition + assignment + skills) → instruction file.
-				const runtime = getRuntime(opts.runtime ?? config.runtime.default, config.runtime.default);
+				const runtime = getRuntime(
+					runtimeNameForCapability(config.runtime, capability, opts.runtime),
+					config.runtime.default,
+				);
+				// Surface project skip-defaults as constraints the spawning agent obeys.
+				const skipDirectives: string[] = [];
+				if (def.canSpawn && config.agents.skipScout) {
+					skipDirectives.push("Skip the scout step — dispatch builders directly (--skip-scout).");
+				}
+				if (def.canSpawn && config.agents.skipReview) {
+					skipDirectives.push("Skip the reviewer step before integrating (--skip-review).");
+				}
 				const overlayConfig: OverlayConfig = {
 					agentName: name,
 					capability,
@@ -173,7 +184,7 @@ export function createSlingCommand(): Command {
 					baseDefinition: readBaseDefinition(root, def.file),
 					canSpawn: def.canSpawn,
 					qualityGates: config.project.qualityGates ?? [],
-					constraints: def.constraints,
+					constraints: [...def.constraints, ...skipDirectives],
 					siblings: opts.siblings ? opts.siblings.split(",").map((s) => s.trim()) : undefined,
 					skillsOverlay: skillsOverlay || undefined,
 				};

package/src/commands/stop.ts

@@ -7,22 +7,30 @@
 import { Command } from "commander";
 import { findProjectRoot, isInitialized } from "../config.ts";
 import { NotFoundError, ValidationError } from "../errors.ts";
+import { createEventStore } from "../events/store.ts";
 import { jsonOutput } from "../json.ts";
 import { printSuccess, printWarning } from "../logging/color.ts";
-import { sessionsDbPath } from "../paths.ts";
+import { createMailStore } from "../mail/store.ts";
+import { createMergeQueue } from "../merge/queue.ts";
+import { eventsDbPath, mailDbPath, mergeDbPath, sessionsDbPath } from "../paths.ts";
+import { type PurgeReport, purgeAgentData } from "../sessions/purge.ts";
 import { createSessionStore } from "../sessions/store.ts";
-import { removeWorktree } from "../worktree/manager.ts";
+import { deleteBranch, removeWorktree } from "../worktree/manager.ts";
 
 export function createStopCommand(): Command {
 	return new Command("stop")
 		.description("Terminate an agent session")
 		.argument("<agent>", "agent name")
 		.option("--clean-worktree", "also remove the agent's worktree")
+		.option(
+			"--purge",
+			"fully erase the agent (worktree + mail, events, merges, state dir, session row)",
+		)
 		.option("--json", "output JSON")
 		.action(
 			async (
 				agent: string,
-				opts: { cleanWorktree?: boolean; json?: boolean },
+				opts: { cleanWorktree?: boolean; purge?: boolean; json?: boolean },
 				command: Command,
 			) => {
 				const useJson = command.optsWithGlobals().json === true;
@@ -30,6 +38,8 @@ export function createStopCommand(): Command {
 				if (!isInitialized(root)) {
 					throw new ValidationError("Not initialized. Run `agentplate setup` first.");
 				}
+				// --purge implies removing the worktree: a full wipe leaves no worktree.
+				const cleanWorktree = opts.cleanWorktree || opts.purge === true;
 				const store = createSessionStore(sessionsDbPath(root));
 				try {
 					const session = store.getSessionByAgent(agent);
@@ -37,17 +47,44 @@ export function createStopCommand(): Command {
 					store.updateSessionState(session.id, "stopped");
 
 					let worktreeRemoved = false;
-					if (opts.cleanWorktree) {
+					if (cleanWorktree) {
 						try {
 							await removeWorktree(root, session.worktreePath, { force: true });
 							worktreeRemoved = true;
+							// Best-effort branch cleanup (may be merged/shared — leave it then).
+							try {
+								await deleteBranch(root, session.branchName);
+							} catch {
+								// Branch kept; not fatal.
+							}
 						} catch (error) {
 							printWarning(`Could not remove worktree: ${(error as Error).message}`);
 						}
 					}
 
-					if (useJson) jsonOutput({ agent, stopped: true, worktreeRemoved });
-					else printSuccess(`Stopped ${agent}${worktreeRemoved ? " (worktree removed)" : ""}`);
+					let purged: PurgeReport | null = null;
+					if (opts.purge) {
+						const events = createEventStore(eventsDbPath(root));
+						const merge = createMergeQueue(mergeDbPath(root));
+						const mail = createMailStore(mailDbPath(root));
+						try {
+							purged = purgeAgentData(root, session, { sessions: store, events, merge, mail });
+						} finally {
+							events.close();
+							merge.close();
+							mail.close();
+						}
+					}
+
+					if (useJson) {
+						jsonOutput({ agent, stopped: true, worktreeRemoved, purged });
+					} else if (purged) {
+						printSuccess(
+							`Purged ${agent} (worktree removed, ${purged.mailDeleted} mail/${purged.eventsDeleted} events/${purged.mergeDeleted} merges erased)`,
+						);
+					} else {
+						printSuccess(`Stopped ${agent}${worktreeRemoved ? " (worktree removed)" : ""}`);
+					}
 				} finally {
 					store.close();
 				}

package/src/commands/turn.ts

@@ -12,19 +12,15 @@
  * call is one fresh, resumed runtime subprocess.
  */
 
-import { existsSync } from "node:fs";
 import { Command } from "commander";
-import { driveTurn } from "../agents/drive.ts";
-import { buildDefaultManifest, getDefinition, loadManifest } from "../agents/manifest.ts";
+import { driveAgentTurn } from "../agents/drive.ts";
 import { findProjectRoot, isInitialized, loadConfig } from "../config.ts";
 import { NotFoundError, ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
 import { jsonOutput } from "../json.ts";
 import { brand, muted, printInfo, printSuccess } from "../logging/color.ts";
 import { createMailClient } from "../mail/client.ts";
-import { eventsDbPath, manifestFilePath, sessionsDbPath } from "../paths.ts";
-import { getRuntime } from "../runtimes/registry.ts";
-import { resolveModel } from "../runtimes/resolve.ts";
+import { eventsDbPath, sessionsDbPath } from "../paths.ts";
 import { createSessionStore } from "../sessions/store.ts";
 import type { SessionState } from "../types.ts";
 
@@ -60,34 +56,13 @@ export function createTurnCommand(): Command {
 					);
 				}
 
-				const manifestPath = manifestFilePath(root);
-				const manifest = existsSync(manifestPath)
-					? loadManifest(manifestPath)
-					: buildDefaultManifest();
-				const def = getDefinition(manifest, session.capability);
-				const runtime = getRuntime(config.runtime.default, config.runtime.default);
-				const model = resolveModel(config, root, def.model, session.capability);
-
-				// The next turn's user text is the agent's unread mail (e.g. a child's
-				// reply or operator direction); fall back to a continue nudge.
-				const injected = mail.checkInject(agent);
-				const prompt =
-					injected.trim().length > 0
-						? injected
-						: "Continue your task. If it is complete, send your terminal mail.";
-
-				const { finalState, exitCode } = await driveTurn({
+				const { finalState, exitCode } = await driveAgentTurn({
 					root,
 					config,
-					runtime,
+					session,
 					store,
 					events,
 					mail,
-					session,
-					model,
-					prompt,
-					// Warm start: resume the runtime session captured on a prior turn.
-					resumeSessionId: session.runtimeSessionId ?? undefined,
 				});
 
 				if (useJson) {