Dynamic workflows for the agent tool you already use.

export const meta = {
	name: 'implementation-review',
	phases: [{ title: 'Implement' }, { title: 'Review' }],
};

phase('Implement');
const outcome = await gate(
	(feedback, attempt) =>
		agent(`Implement attempt ${attempt + 1}. Run the relevant checks.`, {
			model: 'codex/gpt-5.6-sol',
			configOptions: { reasoning_effort: 'max' },
		}),
	async (implementation) => {
		phase('Review');
		const reviews = await parallel([
			() =>
				agent('Review this implementation for correctness…', {
					model: 'claude/opus[1m]',
					schema: VERDICT,
				}),
			() =>
				agent('Review this implementation for product truth…', {
					model: 'pi/moonshotai/kimi-k3',
					schema: VERDICT,
				}),
		]);
		// a changes-requested verdict starts implementation attempt 2
	},
	{ attempts: 3 },
);

export const meta = {
	name: 'implementation-review',
	description:
		'Implement a request, review it independently, and revise until approved',
	phases: [{ title: 'Implement' }, { title: 'Review' }],
};

const input =
	typeof args === 'string'
		? JSON.parse(args)
		: args && typeof args === 'object' && !Array.isArray(args)
			? args
			: {};
if (typeof input.request !== 'string' || !input.request.trim()) {
	throw new Error("args.request must contain the user's request");
}

const VERDICT = {
	type: 'object',
	additionalProperties: false,
	required: ['ok', 'feedback'],
	properties: {
		ok: {
			type: 'boolean',
			description: 'True only when the implementation satisfies the request',
		},
		feedback: {
			type: 'string',
			description: 'Specific evidence-backed changes required when ok is false',
		},
	},
};

const approved = await checkpoint(
	`Start the implementation and review workflow for this request?\n${input.request}`,
	{ kind: 'confirm', default: true },
);
if (!approved) return { validated: false, reason: 'not approved' };

phase('Implement');
const outcome = await gate(
	(feedback, attempt) =>
		agent(
			`User request:\n${input.request}\n\n` +
				`Implement attempt ${attempt + 1}. Run the relevant checks.` +
				(feedback ? `\n\nReview feedback:\n${feedback}` : ''),
			{
				label: `implementation:${attempt + 1}`,
				model: 'codex/gpt-5.6-sol',
				mode: 'agent',
				configOptions: { reasoning_effort: 'max' },
				retries: 1,
			},
		),
	async (implementation) => {
		if (!implementation) {
			return {
				ok: false,
				feedback: 'The implementation call did not complete.',
			};
		}

		phase('Review');
		const reviews = (
			await parallel([
				() =>
					agent(
						`Review this implementation for correctness.\nUser request:\n${input.request}\n\nImplementation report:\n${implementation}`,
						{
							label: 'review:correctness',
							model: 'claude/opus[1m]',
							mode: 'plan',
							configOptions: { effort: 'max' },
							schema: VERDICT,
						},
					),
				() =>
					agent(
						`Review this implementation for product truth.\nUser request:\n${input.request}\n\nImplementation report:\n${implementation}`,
						{
							label: 'review:product-truth',
							model: 'pi/moonshotai/kimi-k3',
							configOptions: { thinkingLevel: 'max' },
							schema: VERDICT,
						},
					),
			])
		).filter(Boolean);

		if (reviews.length !== 2) {
			return {
				ok: false,
				feedback: 'An independent review call did not complete.',
			};
		}
		const changes = reviews.filter((review) => !review.ok);
		return changes.length
			? {
					ok: false,
					feedback: changes.map((review) => review.feedback).join('\n'),
				}
			: { ok: true, feedback: '' };
	},
	{ attempts: 3 },
);

return {
	validated: outcome.ok,
	attempts: outcome.attempts,
	result: outcome.value,
};