chore: enhancing prompts

Author: nicholasgriffintn

apps/api/src/routes/sandbox.ts

@@ -36,6 +36,7 @@ sandbox.post(
 			task: payload.task,
 			taskType: payload.taskType,
 			model: payload.model,
+			promptStrategy: payload.promptStrategy,
 			shouldCommit: Boolean(payload.shouldCommit),
 			installationId: payload.installationId,
 			stream: c.req.header("accept")?.includes("text/event-stream"),

apps/api/src/services/apps/sandbox/__test__/execute-stream.test.ts

@@ -96,6 +96,7 @@ describe("executeSandboxRunStream", () => {
 				installationId: 100,
 				repo: "owner/repo",
 				task: "Ship it",
+				promptStrategy: "bug-fix",
 				shouldCommit: true,
 			},
 		});
@@ -108,13 +109,20 @@ describe("executeSandboxRunStream", () => {
 				repo: "owner/repo",
 				task: "Ship it",
 				model: "mistral-large",
+				promptStrategy: "bug-fix",
 				shouldCommit: true,
 				status: "completed",
 			}),
 		});
+		expect(executeSandboxWorker).toHaveBeenCalledWith(
+			expect.objectContaining({
+				promptStrategy: "bug-fix",
+			}),
+		);
 		expect(mockUpdateAppData).toHaveBeenCalledTimes(2);
 		expect(mockUpdateAppData.mock.calls[1]?.[1]).toMatchObject({
 			status: "completed",
+			promptStrategy: "bug-fix",
 			result: {
 				success: true,
 				result: { ok: true },

apps/api/src/services/apps/sandbox/__test__/run-data.test.ts

@@ -77,6 +77,40 @@ describe("sandbox run data helpers", () => {
 		});
 	});
 
+	it("parses and returns optional prompt strategy metadata", () => {
+		const parsed = parseSandboxRunData({
+			runId: "run-3",
+			installationId: 101,
+			repo: "owner/repo",
+			task: "Fix flaky tests",
+			model: "mistral-large",
+			promptStrategy: "bug-fix",
+			shouldCommit: false,
+			status: "running",
+			startedAt: "2026-02-17T12:00:00.000Z",
+			updatedAt: "2026-02-17T12:00:01.000Z",
+		});
+
+		expect(parsed).toMatchObject({
+			promptStrategy: "bug-fix",
+		});
+
+		expect(
+			toSandboxRunResponse({
+				runId: "run-4",
+				installationId: 100,
+				repo: "owner/repo",
+				task: "Refactor duplicate code",
+				model: "mistral-large",
+				promptStrategy: "refactor",
+				shouldCommit: false,
+				status: "completed",
+				startedAt: "2026-02-17T12:00:00.000Z",
+				updatedAt: "2026-02-17T12:00:01.000Z",
+			}).promptStrategy,
+		).toBe("refactor");
+	});
+
 	it("limits appended events to max length", () => {
 		const result = appendSandboxRunEvent(
 			[{ type: "event-1" }, { type: "event-2" }],

apps/api/src/services/apps/sandbox/execute-stream.ts

@@ -111,6 +111,7 @@ export async function executeSandboxRunStream(
 		repo: payload.repo,
 		task: payload.task,
 		model,
+		promptStrategy: payload.promptStrategy,
 		shouldCommit: Boolean(payload.shouldCommit),
 		status: "queued",
 		startedAt: now,
@@ -152,6 +153,7 @@ export async function executeSandboxRunStream(
 			repo: payload.repo,
 			task: payload.task,
 			model,
+			promptStrategy: payload.promptStrategy,
 			shouldCommit: payload.shouldCommit,
 			installationId: payload.installationId,
 			stream: true,

apps/api/src/services/apps/sandbox/run-data.ts

@@ -33,6 +33,7 @@ export function toSandboxRunResponse(data: SandboxRunData): SandboxRun {
 		repo: data.repo,
 		task: data.task,
 		model: data.model,
+		promptStrategy: data.promptStrategy,
 		shouldCommit: data.shouldCommit,
 		status: data.status,
 		startedAt: data.startedAt,

apps/api/src/services/apps/sandbox/stream-proxy.ts

@@ -56,6 +56,7 @@ export function createSandboxEventProxyStream(
 			let errorMessage: string | undefined;
 			let completedAt: string | undefined;
 			let cancellationReason: string | undefined;
+			let promptStrategy = runData.promptStrategy;
 
 			const pushEvent = (event: SandboxRunEvent) => {
 				const next = appendSandboxRunEvent(
@@ -110,6 +111,10 @@ export function createSandboxEventProxyStream(
 				if (parsed.type === "run_started") {
 					status = "running";
 				}
+
+				if (parsed.promptStrategy) {
+					promptStrategy = parsed.promptStrategy;
+				}
 			};
 
 			try {
@@ -238,6 +243,7 @@ export function createSandboxEventProxyStream(
 						status,
 						result,
 						error: status === "failed" ? errorMessage : undefined,
+						promptStrategy,
 						events,
 						updatedAt: new Date().toISOString(),
 						completedAt,

apps/api/src/services/functions/sandbox.ts

@@ -1,5 +1,9 @@
 import type { IFunction } from "~/types";
 import { executeSandboxWorker } from "~/services/sandbox/worker";
+import {
+	sandboxPromptStrategySchema,
+	type SandboxPromptStrategy,
+} from "@assistant/schemas";
 
 export const run_feature_implementation: IFunction = {
 	name: "run_feature_implementation",
@@ -22,6 +26,11 @@ export const run_feature_implementation: IFunction = {
 				type: "string",
 				description: "Model to use (required if not configured in settings)",
 			},
+			promptStrategy: {
+				type: "string",
+				description:
+					"Optional prompting strategy (auto, feature-delivery, bug-fix, refactor, test-hardening)",
+			},
 			shouldCommit: {
 				type: "boolean",
 				description:
@@ -42,13 +51,21 @@ export const run_feature_implementation: IFunction = {
 		_app_url,
 		_conversationManager,
 	) => {
-		const { repo, task, model, shouldCommit } = args as {
+		const { repo, task, model, promptStrategy, shouldCommit } = args as {
 			repo: string;
 			task: string;
 			model?: string;
+			promptStrategy?: string;
 			shouldCommit?: boolean;
 			installationId?: number;
 		};
+		const parsedPromptStrategyResult = sandboxPromptStrategySchema.safeParse(
+			typeof promptStrategy === "string" ? promptStrategy.trim() : undefined,
+		);
+		const parsedPromptStrategy: SandboxPromptStrategy | undefined =
+			parsedPromptStrategyResult.success
+				? parsedPromptStrategyResult.data
+				: undefined;
 
 		if (!request.context || !request.user) {
 			throw new Error("User context is required for sandbox execution");
@@ -63,6 +80,7 @@ export const run_feature_implementation: IFunction = {
 			repo,
 			task,
 			model,
+			promptStrategy: parsedPromptStrategy,
 			shouldCommit,
 			installationId:
 				typeof (args as { installationId?: unknown }).installationId ===

apps/api/src/services/sandbox/worker.ts

@@ -1,5 +1,6 @@
 import type { ServiceContext } from "~/lib/context/serviceContext";
 import type {
+	SandboxPromptStrategy,
 	SandboxTaskType,
 	SandboxWorkerExecuteRequest,
 } from "@assistant/schemas";
@@ -23,6 +24,7 @@ export interface ExecuteSandboxWorkerOptions {
 	task: string;
 	model?: string;
 	taskType?: SandboxTaskType;
+	promptStrategy?: SandboxPromptStrategy;
 	shouldCommit?: boolean;
 	installationId?: number;
 	stream?: boolean;
@@ -94,6 +96,7 @@ export async function executeSandboxWorker(
 		repo,
 		task,
 		taskType,
+		promptStrategy,
 		shouldCommit,
 		installationId,
 		stream,
@@ -139,6 +142,7 @@ export async function executeSandboxWorker(
 		repo,
 		task,
 		model,
+		promptStrategy,
 		shouldCommit: Boolean(shouldCommit),
 		polychatApiUrl: resolveApiBaseUrl(env),
 		installationId,

apps/app/src/lib/sandbox/prompt-strategies.ts

@@ -0,0 +1,69 @@
+import {
+	SANDBOX_PROMPT_STRATEGIES,
+	type SandboxPromptStrategy,
+} from "@assistant/schemas";
+
+interface PromptStrategyOption {
+	value: SandboxPromptStrategy;
+	label: string;
+	description: string;
+}
+
+const PROMPT_STRATEGY_LABELS: Record<SandboxPromptStrategy, string> = {
+	auto: "Auto",
+	"feature-delivery": "Feature Delivery",
+	"bug-fix": "Bug Fix",
+	refactor: "Refactor",
+	"test-hardening": "Test Hardening",
+};
+
+const PROMPT_STRATEGY_DESCRIPTIONS: Record<SandboxPromptStrategy, string> = {
+	auto: "Let the worker choose based on the task and repository context.",
+	"feature-delivery": "Optimise for shipping user-facing functionality safely.",
+	"bug-fix": "Focus on root-cause analysis and regression prevention.",
+	refactor:
+		"Prioritise maintainability improvements while preserving behaviour.",
+	"test-hardening":
+		"Focus on high-signal validation, state, and error-path coverage.",
+};
+
+export const sandboxPromptStrategyOptions: PromptStrategyOption[] =
+	SANDBOX_PROMPT_STRATEGIES.map((strategy) => ({
+		value: strategy,
+		label: PROMPT_STRATEGY_LABELS[strategy],
+		description: PROMPT_STRATEGY_DESCRIPTIONS[strategy],
+	}));
+
+export function getSandboxPromptStrategyLabel(
+	strategy?: SandboxPromptStrategy,
+): string {
+	if (!strategy) {
+		return PROMPT_STRATEGY_LABELS.auto;
+	}
+	return PROMPT_STRATEGY_LABELS[strategy] ?? strategy;
+}
+
+export function getSandboxPromptStrategyDescription(
+	strategy: SandboxPromptStrategy,
+): string {
+	return PROMPT_STRATEGY_DESCRIPTIONS[strategy];
+}
+
+export function isSandboxPromptStrategy(
+	value: string,
+): value is SandboxPromptStrategy {
+	for (const strategy of SANDBOX_PROMPT_STRATEGIES) {
+		if (strategy === value) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function parseSandboxPromptStrategy(
+	value: string,
+	fallback: SandboxPromptStrategy = "auto",
+): SandboxPromptStrategy {
+	return isSandboxPromptStrategy(value) ? value : fallback;
+}

apps/app/src/pages/apps/sandbox/[connectionId].tsx

@@ -30,6 +30,7 @@ import {
 	CardHeader,
 	CardTitle,
 	Checkbox,
+	FormSelect,
 	Input,
 	Label,
 	Textarea,
@@ -44,9 +45,19 @@ import {
 import { useAuthStatus } from "~/hooks/useAuth";
 import { formatRelativeTime } from "~/lib/dates";
 import { streamSandboxRun } from "~/lib/api/sandbox";
+import {
+	getSandboxPromptStrategyDescription,
+	getSandboxPromptStrategyLabel,
+	parseSandboxPromptStrategy,
+	sandboxPromptStrategyOptions,
+} from "~/lib/sandbox/prompt-strategies";
 import { normaliseGitHubRepoInput } from "~/lib/sandbox/repositories";
 import { cn } from "~/lib/utils";
-import type { SandboxRun, SandboxRunEvent } from "~/types/sandbox";
+import type {
+	SandboxPromptStrategy,
+	SandboxRun,
+	SandboxRunEvent,
+} from "~/types/sandbox";
 import {
 	REPO_PATTERN,
 	REPO_STORAGE_PREFIX,
@@ -175,6 +186,8 @@ export default function SandboxConnectionPage() {
 	const [repo, setRepo] = useState("");
 	const [task, setTask] = useState("");
 	const [model, setModel] = useState("");
+	const [promptStrategy, setPromptStrategy] =
+		useState<SandboxPromptStrategy>("auto");
 	const [shouldCommit, setShouldCommit] = useState(true);
 	const [isSubmitting, setIsSubmitting] = useState(false);
 	const [activeRunId, setActiveRunId] = useState<string | undefined>();
@@ -412,6 +425,7 @@ export default function SandboxConnectionPage() {
 					repo: trimmedRepo,
 					task: trimmedTask,
 					model: model.trim() || undefined,
+					promptStrategy,
 					shouldCommit,
 				},
 				{
@@ -593,7 +607,7 @@ export default function SandboxConnectionPage() {
 								</CardDescription>
 							</CardHeader>
 							<CardContent className="space-y-4">
-								<div className="grid gap-4 md:grid-cols-2">
+								<div className="grid gap-4 md:grid-cols-3">
 									<div className="space-y-2">
 										<Label htmlFor="sandbox-repo-input">Repository</Label>
 										<Input
@@ -635,6 +649,25 @@ export default function SandboxConnectionPage() {
 											set, backend defaults to <code>mistral-large</code>.
 										</p>
 									</div>
+									<div className="space-y-2">
+										<FormSelect
+											id="sandbox-prompt-strategy"
+											label="Prompt strategy"
+											value={promptStrategy}
+											onChange={(event) =>
+												setPromptStrategy(
+													parseSandboxPromptStrategy(event.target.value),
+												)
+											}
+											options={sandboxPromptStrategyOptions.map((option) => ({
+												value: option.value,
+												label: option.label,
+											}))}
+										/>
+										<p className="text-xs text-muted-foreground">
+											{getSandboxPromptStrategyDescription(promptStrategy)}
+										</p>
+									</div>
 								</div>
 								<div className="space-y-2">
 									<Label htmlFor="sandbox-task-input">Task</Label>
@@ -838,6 +871,12 @@ export default function SandboxConnectionPage() {
 										<p className="text-muted-foreground">
 											{summariseRunResult(selectedRun)}
 										</p>
+										<p>
+											<span className="font-medium">Prompt strategy:</span>{" "}
+											{getSandboxPromptStrategyLabel(
+												selectedRun.promptStrategy,
+											)}
+										</p>
 										{typeof selectedRun.result?.branchName === "string" && (
 											<p>
 												<span className="font-medium">Branch:</span>{" "}