@possumtech/rummy 2.0.0 → 2.1.0

package/src/plugins/openai/openai.js

@@ -1,16 +1,12 @@
+import config from "../../agent/config.js";
 import msg from "../../agent/messages.js";
+import { chatCompletionStream } from "../../llm/openaiStream.js";
 
-const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
-if (!FETCH_TIMEOUT) throw new Error("RUMMY_FETCH_TIMEOUT must be set");
+const { FETCH_TIMEOUT } = config;
 
 const PROVIDER = "openai";
 
-/**
- * OpenAI-compatible LLM provider plugin. Registers with hooks.llm.providers
- * if OPENAI_BASE_URL is set in env; silently inert otherwise. Handles
- * model aliases of the form `openai/{modelName}` — the first path
- * segment picks the provider, the rest is whatever the API expects.
- */
+// Inert unless OPENAI_BASE_URL is set; openai/{model} aliases.
 export default class OpenAi {
 	#baseUrl;
 	#apiKey;
@@ -42,47 +38,36 @@ export default class OpenAi {
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: timeoutSignal;
 
-		const headers = { "Content-Type": "application/json" };
+		const headers = {};
 		if (this.#apiKey) headers.Authorization = `Bearer ${this.#apiKey}`;
 
-		const response = await fetch(`${this.#baseUrl}/v1/chat/completions`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body),
-			signal,
-		});
-
-		if (!response.ok) {
-			const error = await response.text();
-			throw new Error(
-				msg("error.openai_api", { status: `${response.status} - ${error}` }),
-			);
-		}
-
-		const data = await response.json();
-
-		for (const choice of data.choices) {
-			const m = choice.message;
-			if (!m) continue;
-			const parts = [m.reasoning_content, m.reasoning, m.thinking].filter(
-				Boolean,
-			);
-			m.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
-
-			// Full reasoning dump is centralized in telemetry.js on every
-			// provider — keeping it out of provider plugins avoids double
-			// printing and per-provider drift.
+		try {
+			return await chatCompletionStream({
+				url: `${this.#baseUrl}/v1/chat/completions`,
+				headers,
+				body,
+				signal,
+			});
+		} catch (err) {
+			if (err.status) {
+				const wrapped = new Error(
+					msg("error.openai_api", { status: `${err.status} - ${err.body}` }),
+					{ cause: err },
+				);
+				wrapped.status = err.status;
+				wrapped.body = err.body;
+				wrapped.retryAfter = err.retryAfter;
+				throw wrapped;
+			}
+			throw err;
 		}
-
-		return data;
 	}
 
 	async #getContextSize(_model) {
 		const headers = { "Content-Type": "application/json" };
 		if (this.#apiKey) headers.Authorization = `Bearer ${this.#apiKey}`;
 
-		// Try /props first — llama.cpp exposes runtime n_ctx here.
+		// llama.cpp /props returns runtime n_ctx; absent on vanilla OpenAI.
 		try {
 			const propsResponse = await fetch(`${this.#baseUrl}/props`, {
 				headers,
@@ -93,10 +78,7 @@ export default class OpenAi {
 				const runtimeCtx = props?.default_generation_settings?.n_ctx;
 				if (runtimeCtx) return runtimeCtx;
 			}
-		} catch (_err) {
-			// /props is a llama.cpp extension; absent on vanilla OpenAI.
-			// Fall through to /v1/models for the training-context-size hint.
-		}
+		} catch (_err) {}
 
 		// Fall back to /v1/models for training context.
 		const response = await fetch(`${this.#baseUrl}/v1/models`, {

package/src/plugins/openrouter/openrouter.js

@@ -1,20 +1,12 @@
+import config from "../../agent/config.js";
 import msg from "../../agent/messages.js";
+import { chatCompletionStream } from "../../llm/openaiStream.js";
 
-const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
-if (!FETCH_TIMEOUT) throw new Error("RUMMY_FETCH_TIMEOUT must be set");
+const { FETCH_TIMEOUT } = config;
 
 const PROVIDER = "openrouter";
 
-/**
- * OpenRouter LLM provider plugin. Handles model aliases of the form
- * `openrouter/{publisher}/{modelName}`. Strips only the provider
- * segment — OpenRouter's own API expects the `publisher/model` form,
- * so that's exactly what's passed through to it (e.g.
- * `openrouter/anthropic/claude-3-opus` → API receives
- * `anthropic/claude-3-opus`).
- *
- * Inert if OPENROUTER_API_KEY / OPENROUTER_BASE_URL aren't set.
- */
+// Inert unless OPENROUTER_API_KEY+OPENROUTER_BASE_URL set; openrouter/{publisher}/{model} aliases.
 export default class OpenRouter {
 	#apiKey;
 	#baseUrl;
@@ -48,52 +40,36 @@ export default class OpenRouter {
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: timeoutSignal;
 
-		const response = await fetch(`${this.#baseUrl}/chat/completions`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${this.#apiKey}`,
-				"Content-Type": "application/json",
-				"HTTP-Referer": process.env.RUMMY_HTTP_REFERER,
-				"X-Title": process.env.RUMMY_X_TITLE,
-			},
-			body: JSON.stringify(body),
-			signal,
-		});
+		const headers = {
+			Authorization: `Bearer ${this.#apiKey}`,
+			"HTTP-Referer": process.env.RUMMY_HTTP_REFERER,
+			"X-Title": process.env.RUMMY_X_TITLE,
+		};
 
-		if (!response.ok) {
-			const error = await response.text();
-			if (response.status === 401 || response.status === 403) {
+		try {
+			return await chatCompletionStream({
+				url: `${this.#baseUrl}/chat/completions`,
+				headers,
+				body,
+				signal,
+			});
+		} catch (err) {
+			if (err.status === 401 || err.status === 403) {
 				throw new Error(
 					msg("error.openrouter_auth", {
-						status: `${response.status} - ${error}`,
+						status: `${err.status} - ${err.body}`,
 					}),
 				);
 			}
-			throw new Error(
-				msg("error.openrouter_api", {
-					status: `${response.status} - ${error}`,
-				}),
-			);
-		}
-		const data = await response.json();
-
-		for (const choice of data.choices) {
-			const cm = choice.message;
-			if (!cm) continue;
-			const details = cm.reasoning_details
-				? cm.reasoning_details.map((d) => d.text)
-				: [];
-			const parts = [
-				cm.reasoning_content,
-				cm.reasoning,
-				cm.thinking,
-				...details,
-			].filter(Boolean);
-			cm.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
+			if (err.status) {
+				throw new Error(
+					msg("error.openrouter_api", {
+						status: `${err.status} - ${err.body}`,
+					}),
+				);
+			}
+			throw err;
 		}
-
-		return data;
 	}
 
 	async #getContextSize(model) {
@@ -101,7 +77,7 @@ export default class OpenRouter {
 
 		const res = await fetch(`${this.#baseUrl}/models`, {
 			headers: { Authorization: `Bearer ${this.#apiKey}` },
-			signal: AbortSignal.timeout(5000),
+			signal: AbortSignal.timeout(FETCH_TIMEOUT),
 		});
 		if (!res.ok) {
 			throw new Error(

package/src/plugins/policy/README.md

@@ -6,8 +6,14 @@ was started in `ask` mode.
 
 ## Registration
 
-- **Filter**: `entry.recording` (priority 1) — runs before a command
-  becomes an entry.
+- **Filter**: `entry.recording` (priority 1) — the validation /
+  transform hook in TurnExecutor's RECORD phase. Runs after the
+  command is parsed but before the audit row is committed. Returning
+  an object with `state: "failed"` (or `"cancelled"`) short-circuits
+  recording and skips DISPATCH for that command. Plugins may also
+  return a transformed entry (modified body, attributes, path) for
+  the recorder to commit. Filter signature:
+  `(entry, { store, runId, turn, loopId, mode })`.
 
 ## Rejections (ask mode only)
 

package/src/plugins/policy/policy.js

@@ -1,39 +1,28 @@
 import Entries from "../../agent/Entries.js";
 
 export default class Policy {
-	#core;
-
 	constructor(core) {
-		this.#core = core;
 		core.filter("entry.recording", this.#enforceAskMode.bind(this), 1);
 	}
 
-	async #reject(ctx, message) {
-		await this.#core.hooks.error.log.emit({
-			store: ctx.store,
-			runId: ctx.runId,
-			turn: ctx.turn,
-			loopId: ctx.loopId,
-			message,
-		});
+	#fail(entry, body) {
+		return { ...entry, body, state: "failed", outcome: "permission" };
 	}
 
 	async #enforceAskMode(entry, ctx) {
 		if (ctx.mode !== "ask") return entry;
 
 		if (entry.scheme === "sh") {
-			await this.#reject(ctx, "Rejected <sh> in ask mode");
-			return { ...entry, state: "failed", outcome: "permission" };
+			return this.#fail(entry, "Rejected <sh> in ask mode");
 		}
 
 		if (entry.scheme === "set" && entry.attributes?.path) {
 			const scheme = Entries.scheme(entry.attributes.path);
 			if (scheme === null && entry.body) {
-				await this.#reject(
-					ctx,
+				return this.#fail(
+					entry,
 					`Rejected file edit to ${entry.attributes.path} in ask mode`,
 				);
-				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 
@@ -41,19 +30,17 @@ export default class Policy {
 			const pathAttr = entry.attributes?.path || entry.path;
 			const scheme = Entries.scheme(pathAttr);
 			if (scheme === null) {
-				await this.#reject(ctx, `Rejected file rm of ${pathAttr} in ask mode`);
-				return { ...entry, state: "failed", outcome: "permission" };
+				return this.#fail(entry, `Rejected file rm of ${pathAttr} in ask mode`);
 			}
 		}
 
 		if (entry.scheme === "mv" || entry.scheme === "cp") {
 			const destScheme = Entries.scheme(entry.attributes?.to);
 			if (destScheme === null) {
-				await this.#reject(
-					ctx,
+				return this.#fail(
+					entry,
 					`Rejected ${entry.scheme} to file ${entry.attributes?.to} in ask mode`,
 				);
-				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 

package/src/plugins/prompt/README.md

@@ -14,3 +14,25 @@ Finds the latest `prompt://` entry in the turn_context rows. The mode
 attribute (available tool list) and optional `warn` attribute in ask
 mode. Falls back to the mode passed by the core if no prompt entry
 exists.
+
+## Archived prompts: the singular exception to invisibility
+
+`v_model_context.sql` filters archived entries out of the model's
+context — every scheme **except `prompt`**. Archived `prompt://`
+entries flow through with `effective_visibility = 'archived'` and
+their body suppressed (per `projected.body`'s visibility CASE). The
+plugin then renders the tag with full attributes (`path`,
+`visibility="archived"`, etc.) but empty body.
+
+The exception exists because the prompt is run identity: every other
+archived entry is recoverable by pattern search if the model ever
+needs it back, but the prompt is the question the run is answering.
+A model that loses sight of its prompt cannot honestly act. Keeping
+the archived prompt's path visible lets the model emit
+`<get path="prompt://N"/>` to promote it back if it archived
+prematurely (or step back to an earlier stage via
+`<update status="174">`).
+
+This is the only entry-type exception to the "archived = invisible"
+contract. New schemes that warrant similar treatment should be added
+explicitly here, not by accident.

package/src/plugins/prompt/prompt.js

@@ -1,3 +1,5 @@
+const SUMMARIZED_PROMPT_CHAR_CAP = 500;
+
 export default class Prompt {
 	#core;
 
@@ -7,22 +9,23 @@ export default class Prompt {
 		core.hooks.tools.onView(
 			"prompt",
 			(entry) => {
-				const limit = 500;
 				const full = entry.body;
-				if (full.length <= limit) return full;
-				return `${full.slice(0, limit)}\n[truncated — promote to see the complete prompt]`;
+				if (full.length <= SUMMARIZED_PROMPT_CHAR_CAP) return full;
+				return `${full.slice(0, SUMMARIZED_PROMPT_CHAR_CAP)}\n[truncated — promote to see the complete prompt]`;
 			},
 			"summarized",
 		);
 		core.on("turn.started", this.onTurnStarted.bind(this));
-		core.filter("assembly.user", this.assemblePrompt.bind(this), 300);
+		core.filter("assembly.user", this.assemblePrompt.bind(this), 225);
 	}
 
 	async onTurnStarted({ rummy, mode, prompt, isContinuation }) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 
 		if (!isContinuation && prompt) {
-			// prompt:// writable_by: ["plugin"] — explicit for clarity.
+			// New prompt = new cycle; archive prior cycle's prompts/logs (knowns/unknowns persist).
+			await store.archivePriorPromptArtifacts(runId, turn);
+
 			await store.set({
 				runId,
 				turn,
@@ -37,7 +40,7 @@ export default class Prompt {
 	}
 
 	async assemblePrompt(content, ctx) {
-		const { rows, contextSize, toolSet } = ctx;
+		const { rows, toolSet } = ctx;
 		const promptEntry = rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
@@ -57,12 +60,7 @@ export default class Prompt {
 		let warn = "";
 		if (mode === "ask") warn = ' warn="File editing disallowed."';
 
-		// Surface the most recent prior-turn budget demotion as a
-		// `reverted="N"` attribute on <prompt>. Historical error
-		// entries sit in <log> but read as ambient noise; this signal
-		// is dynamic and always fresh — the model sees that its
-		// promotions last turn were reverted, in the same spot where
-		// it reads budget numbers.
+		// reverted="N" surfaces last turn's 413 demotion count next to budget numbers.
 		let reverted = "";
 		const priorTurn = ctx.turn - 1;
 		if (priorTurn >= 1) {
@@ -88,9 +86,9 @@ export default class Prompt {
 			? ` visibility="${promptEntry.visibility}"`
 			: "";
 		const tokens =
-			promptEntry?.aTokens != null
-				? ` tokens="${promptEntry.aTokens}"`
-				: "";
-		return `${content}<prompt mode="${mode}"${path} commands="${commands}"${warn}${reverted}${visibility}${tokens}>${body}</prompt>`;
+			promptEntry?.aTokens != null ? ` tokens="${promptEntry.aTokens}"` : "";
+		const lines =
+			promptEntry?.vLines != null ? ` lines="${promptEntry.vLines}"` : "";
+		return `${content}<prompt mode="${mode}"${path} commands="${commands}"${warn}${reverted}${visibility}${tokens}${lines}>${body}</prompt>`;
 	}
 }

package/src/plugins/rm/rm.js

@@ -27,9 +27,12 @@ export default class Rm {
 		await ctx.entries.rm({ runId: ctx.runId, path: target });
 		if (ctx.projectRoot) {
 			const { unlink } = await import("node:fs/promises");
-			const { join } = await import("node:path");
+			const { isAbsolute, join } = await import("node:path");
+			const targetPath = isAbsolute(target)
+				? target
+				: join(ctx.projectRoot, target);
 			try {
-				await unlink(join(ctx.projectRoot, target));
+				await unlink(targetPath);
 			} catch (err) {
 				// File may already be absent — entry rm'd regardless.
 				if (err.code !== "ENOENT") throw err;

package/src/plugins/rm/rmDoc.md

@@ -3,11 +3,11 @@
 Example: <rm path="src/config.js"/>
 <!-- File removal. Simplest form. -->
 
-Example: <rm path="known://temp_*" preview/>
-<!-- Preview before deleting. Safety pattern for bulk operations. -->
+Example: <rm path="known://temp_*" manifest/>
+<!-- Optional: Manifest before deleting. Safety pattern for bulk operations. -->
 
 * Permanent. Prefer <set path="..." visibility="archived"/> to preserve for later retrieval
 <!-- Nudges toward archive over rm. Path attr included so the model sees a complete invocation shape, not a fragment. -->
 
-* `preview` shows what paths would be affected without performing the operation.
-<!-- Canonical preview teaching lives here — rm is the most intuitive 'check before committing' case. Model generalizes to cp/mv/get by analogy. Advanced uses (e.g. archive rediscovery via <get preview>) belong in persona/skill docs, not here. -->
+* `manifest` lists what paths would be affected without performing the operation.
+<!-- Canonical manifest teaching lives here — rm is the most intuitive 'check before committing' case. Model generalizes to cp/mv/get by analogy. Advanced uses (e.g. archive rediscovery via <get manifest>) belong in persona/skill docs, not here. -->

package/src/plugins/rpc/README.md

@@ -29,4 +29,5 @@ all registered tools.
 - `getRuns`, `getRun`
 
 ### Notifications
-- `run/state`, `run/progress`, `run/proposal`, `ui/render`, `ui/notify`, `stream/cancelled`
+- `run/changed` — pulse: an entry under this run changed; client reconciles via `getEntries(run, { since })`.
+- `ui/render`, `ui/notify`, `stream/cancelled`

package/src/plugins/rpc/rpc.js

@@ -24,10 +24,7 @@ export default class Rpc {
 			description: "Returns { methods, notifications } catalog.",
 		});
 
-		// --- Primitives (SPEC primitives) ---
-		// The client surface is a thin projection of the plugin API.
-		// Six verbs, each takes an object of entry-grammar params.
-		// Writer is fixed to "client"; permissions enforced per scheme.
+		// Primitives (SPEC #primitives); writer fixed to "client".
 
 		r.register("set", {
 			handler: async (params, ctx) => {
@@ -139,8 +136,9 @@ export default class Rpc {
 				return { ok: true, path };
 			},
 			description:
-				"Write an update:// entry carrying a turn's continuation/terminal " +
-				"signal. Not general — this is the lifecycle verb.",
+				"Write a status update at log://turn_N/update/<slug> carrying a " +
+				"turn's continuation/terminal signal. Not general — this is the " +
+				"lifecycle verb.",
 			params: {
 				run: "string — run alias",
 				body: "string — update text",
@@ -151,9 +149,7 @@ export default class Rpc {
 			requiresInit: true,
 		});
 
-		// Connection handshake. First call a client makes. Establishes
-		// the project identity for this connection and announces the
-		// server's protocol version.
+		// Connection handshake; project identity + protocol version.
 		r.register("rummy/hello", {
 			handler: async (params, ctx) => {
 				const { RUMMY_PROTOCOL_VERSION } = await import(
@@ -311,11 +307,18 @@ export default class Rpc {
 		r.register("getEntries", {
 			handler: async (params, ctx) => {
 				const runRow = await this.#resolveRun(params.run, ctx);
-				const { pattern = "*", bodyFilter = null } = params;
+				const {
+					pattern = "*",
+					bodyFilter = null,
+					since = null,
+					limit = null,
+					withBody = false,
+				} = params;
 				const rows = await ctx.projectAgent.entries.getEntriesByPattern(
 					runRow.id,
 					pattern,
 					bodyFilter,
+					{ since, limit },
 				);
 				return rows
 					.filter((e) => !params.scheme || e.scheme === params.scheme)
@@ -323,30 +326,43 @@ export default class Rpc {
 					.filter(
 						(e) => !params.visibility || e.visibility === params.visibility,
 					)
-					.map((e) => ({
-						path: e.path,
-						scheme: e.scheme,
-						state: e.state,
-						outcome: e.outcome,
-						visibility: e.visibility,
-						turn: e.turn,
-						tokens: e.tokens,
-						attributes:
-							typeof e.attributes === "string"
-								? JSON.parse(e.attributes)
-								: e.attributes,
-					}));
+					.map((e) => {
+						const row = {
+							id: e.id,
+							path: e.path,
+							scheme: e.scheme,
+							state: e.state,
+							outcome: e.outcome,
+							visibility: e.visibility,
+							turn: e.turn,
+							tokens: e.tokens,
+							attributes:
+								typeof e.attributes === "string"
+									? JSON.parse(e.attributes)
+									: e.attributes,
+						};
+						if (withBody) row.body = e.body;
+						return row;
+					});
 			},
 			description:
 				"List entries matching a pattern. Read-only — no promotion. " +
-				"Optional filters: scheme, state, visibility, bodyFilter.",
+				"Optional filters: scheme, state, visibility, bodyFilter. " +
+				"Pass `withBody: true` to include `body` on each row (omitted by default to keep pulse-reconcile traffic lean). " +
+				"For incremental sync after a `run/changed` pulse, pass `since` (last seen entry id); " +
+				"use `limit` to chunk catch-up.",
 			params: {
 				run: "string — run alias",
 				pattern: "string? — glob pattern (default '*')",
 				scheme: "string? — filter by scheme (e.g. 'file')",
 				state: "string? — filter by state",
 				visibility: "string? — filter by visibility",
-				bodyFilter: "string? — narrow pattern matches by body content",
+				bodyFilter:
+					"string? — filter rows by content of body (substring/glob; NOT for body inclusion — see withBody)",
+				withBody:
+					"boolean? — include `body` field on each returned row (default false)",
+				since: "number? — only entries with id > since (insertion-ordered)",
+				limit: "number? — cap result count",
 			},
 			requiresInit: true,
 		});
@@ -436,9 +452,10 @@ export default class Rpc {
 
 		// --- Notifications ---
 
-		r.registerNotification("run/state", "Turn state update.");
-		r.registerNotification("run/progress", "Turn status.");
-		r.registerNotification("run/proposal", "Proposal awaiting resolution.");
+		r.registerNotification(
+			"run/changed",
+			"Pulse: an entry under this run changed. Query with `getEntries(run, { pattern, since })` to reconcile.",
+		);
 		r.registerNotification(
 			"stream/cancelled",
 			"Server-initiated stream cancellation.",
@@ -446,8 +463,7 @@ export default class Rpc {
 		r.registerNotification("ui/render", "Streaming output.");
 		r.registerNotification("ui/notify", "Toast notification.");
 
-		// Auto-dispatch: any registered tool is callable via RPC.
-		// Checked at request time — no timing dependency on plugin load order.
+		// Any registered tool is callable via RPC; resolved at request time.
 		r.setToolFallback(hooks, buildRunContext, dispatchTool);
 	}
 
@@ -464,18 +480,14 @@ export default class Rpc {
 	async #dispatchSet(params, ctx) {
 		if (!params.path) throw new Error("set: path is required");
 
-		// run:// is the lifecycle surface. A set to a brand-new run://
-		// alias starts a run loop; a state transition cancels or resolves.
+		// run:// = lifecycle surface (start run, cancel, resolve).
 		if (params.path.startsWith("run://")) {
 			return await this.#dispatchRunSet(params, ctx);
 		}
 
 		const runRow = await this.#resolveRun(params.run, ctx);
 
-		// State transition on an existing proposed entry → route through
-		// AgentLoop.resolve, which applies scheme-specific side effects
-		// (patch application for set://, file removal for rm://, stream
-		// setup for sh:// / env://, etc.).
+		// State transitions on proposed entries → AgentLoop.resolve for scheme-specific effects.
 		if (params.state && !params.append && !params.pattern) {
 			const current = await ctx.projectAgent.entries.getState(
 				runRow.id,
@@ -521,10 +533,7 @@ export default class Rpc {
 	async #dispatchRunSet(params, ctx) {
 		let alias = params.path.slice("run://".length);
 
-		// Empty alias on a new-run set → synthesize ${model}_${epoch}.
-		// Matches AgentLoop.#generateAlias so server- and client-initiated
-		// runs share one naming scheme. Clients that want a specific name
-		// pass it in the path; anonymous starts get the synthesized one.
+		// Empty alias → ${model}_${epoch}; mirrors AgentLoop.#generateAlias.
 		if (!alias) {
 			const { attributes: attrs = {} } = params;
 			if (!attrs.model) {
@@ -576,12 +585,11 @@ export default class Rpc {
 				noInteraction: attrs.noInteraction,
 				noWeb: attrs.noWeb,
 				noProposals: attrs.noProposals,
+				yolo: attrs.yolo,
 				fork: attrs.fork,
 			};
 			const { body = "" } = params;
-			// Fire-and-forget: client watches state via entry notifications.
-			// ProjectAgent exposes .ask/.act wrappers over AgentLoop#run; route
-			// by mode rather than calling the private loop directly.
+			// Fire-and-forget; client watches state via entry notifications.
 			const kickoff =
 				mode === "act"
 					? ctx.projectAgent.act(
@@ -604,10 +612,7 @@ export default class Rpc {
 			return { ok: true, alias };
 		}
 
-		// Existing run + fork=true: create a child run synchronously so we
-		// can return the child alias, then kick off the loop against it.
-		// fork needs a brand-new run row with parent_run_id set; inject()
-		// would just add another prompt to the parent.
+		// fork=true → new child run with parent_run_id; inject() would only add a prompt to parent.
 		const attrs = params.attributes ? params.attributes : {};
 		if (attrs.fork === true) {
 			const { mode } = attrs;
@@ -638,6 +643,7 @@ export default class Rpc {
 				noInteraction: attrs.noInteraction,
 				noWeb: attrs.noWeb,
 				noProposals: attrs.noProposals,
+				yolo: attrs.yolo,
 				// fork already applied — pass false to reuse the child row.
 				fork: false,
 			};
@@ -673,7 +679,15 @@ export default class Rpc {
 					`set run://: attributes.mode is required on inject and must be "ask" or "act" (got ${JSON.stringify(mode)})`,
 				);
 			}
-			await ctx.projectAgent.inject(alias, params.body, mode);
+			const options = {
+				temperature: attrs.temperature,
+				noRepo: attrs.noRepo,
+				noInteraction: attrs.noInteraction,
+				noWeb: attrs.noWeb,
+				noProposals: attrs.noProposals,
+				yolo: attrs.yolo,
+			};
+			await ctx.projectAgent.inject(alias, params.body, mode, options);
 			return { ok: true, alias };
 		}