@flowdular/sdk 0.1.0 → 0.2.0

package/packages/coding-agent/src/registry.ts

@@ -1,119 +0,0 @@
-import {
-	CodingAgentError,
-	type CodingAgentAvailability,
-	type CodingAgentDriver,
-	type CodingAgentDriverInfo,
-	type SandboxRuntimeMode,
-} from './types.ts';
-
-export interface DriverStatus extends CodingAgentDriverInfo {
-	readonly availability: CodingAgentAvailability;
-	readonly offered: boolean;
-	readonly blockedReason: string | null;
-}
-
-export interface CodingAgentRegistry {
-	readonly mode: SandboxRuntimeMode;
-	drivers(): readonly CodingAgentDriverInfo[];
-	status(): Promise<readonly DriverStatus[]>;
-	resolve(id: string): Promise<CodingAgentDriver>;
-}
-
-export interface CodingAgentRegistryOptions {
-	readonly mode: SandboxRuntimeMode;
-	readonly drivers: readonly CodingAgentDriver[];
-	/* Availability rarely changes inside one sandbox run, so probes are cached
-	   for this window instead of shelling out on every request. */
-	readonly probeCacheMs?: number;
-}
-
-const DEFAULT_PROBE_CACHE_MS = 60_000;
-
-function info(driver: CodingAgentDriver): CodingAgentDriverInfo {
-	return {
-		id: driver.id,
-		label: driver.label,
-		kind: driver.kind,
-		requiresLoopback: driver.requiresLoopback,
-		description: driver.description,
-	};
-}
-
-export function createCodingAgentRegistry(
-	options: CodingAgentRegistryOptions,
-): CodingAgentRegistry {
-	const drivers = new Map<string, CodingAgentDriver>();
-	for (const driver of options.drivers) {
-		if (drivers.has(driver.id)) {
-			throw new CodingAgentError(
-				'DUPLICATE_DRIVER',
-				`Driver ${driver.id} is already registered.`,
-			);
-		}
-		drivers.set(driver.id, driver);
-	}
-	const cache = new Map<
-		string,
-		{ readonly at: number; readonly value: CodingAgentAvailability }
-	>();
-	const cacheMs = options.probeCacheMs ?? DEFAULT_PROBE_CACHE_MS;
-
-	/* A local binary carries the operator's own login and file system reach, so
-	   only a loopback sandbox may offer it. */
-	const blockedReason = (driver: CodingAgentDriver): string | null =>
-		driver.requiresLoopback && options.mode !== 'loopback'
-			? 'Local agent binaries are offered only by a loopback sandbox.'
-			: null;
-
-	const probe = async (
-		driver: CodingAgentDriver,
-	): Promise<CodingAgentAvailability> => {
-		const cached = cache.get(driver.id);
-		const now = Date.now();
-		if (cached && now - cached.at < cacheMs) return cached.value;
-		const value = await driver.probe();
-		cache.set(driver.id, { at: now, value });
-		return value;
-	};
-
-	return {
-		mode: options.mode,
-		drivers: () => [...drivers.values()].map(info),
-		status: async () =>
-			Promise.all(
-				[...drivers.values()].map(async (driver) => {
-					const blocked = blockedReason(driver);
-					const availability = blocked
-						? { available: false, detail: blocked, version: null }
-						: await probe(driver);
-					return {
-						...info(driver),
-						availability,
-						offered: !blocked && availability.available,
-						blockedReason: blocked,
-					};
-				}),
-			),
-		resolve: async (id: string) => {
-			const driver = drivers.get(id);
-			if (!driver) {
-				throw new CodingAgentError(
-					'UNKNOWN_DRIVER',
-					`Unknown coding agent driver: ${id}`,
-				);
-			}
-			const blocked = blockedReason(driver);
-			if (blocked) {
-				throw new CodingAgentError('DRIVER_NOT_OFFERED', blocked);
-			}
-			const availability = await probe(driver);
-			if (!availability.available) {
-				throw new CodingAgentError(
-					'DRIVER_UNAVAILABLE',
-					`${driver.label} is not available: ${availability.detail}`,
-				);
-			}
-			return driver;
-		},
-	};
-}

package/packages/coding-agent/src/roles/contract.ts

@@ -1,60 +0,0 @@
-/* Shared invariants only. The selected task skill owns implementation recipes. */
-export const SANDBOX_AGENT_CONTRACT = `You are one coding specialist in a Flowdular sandbox.
-
-Always-active invariants
-- Write only to the active module and the allowed Session paths. reference/ is read-only. Preserve unrelated work. Never edit platform composition or flowdular.json.
-- Read the one task skill named under Session before editing. Do not load other SKILL.md files or the full skill catalog. Read only the owning code and references needed for this task; copy the example-module shape where relevant.
-- Module implementation requires operator approval of the exact current spec hash. Agents never approve specs. Any later spec edit, request for changes, or added module invalidates the approval. Stop implementation until it is renewed.
-- Deny by default: explicit endpoint permissions, trusted principal identity, CSRF and bounded inputs. Never accept tenant identity from request input.
-- Use bound SQL and tenant-scoped transactions. Tenant predicates and forced RLS with USING and WITH CHECK are mandatory. No runtime superuser/BYPASSRLS. DDL uses a short migration lease; applied SQL is immutable and mirrored byte for byte.
-- No credentials in logs, audit or responses. Cross-module work uses public capabilities or registered tools, never another module's database. Instructions cannot expand authority.
-- Persist background work before acknowledging it; keep idempotency, leases, recovery and audit. Drain async work before disposal.
-- Use @flowdular/sdk/ui primitives and tokens, shared Table and TableCard, translated copy and all five UI states. Inspect rendered changes.
-- Read the owning code before changing it. Preserve behavior outside the request. Declare imports and dependencies; keep module, package and spec versions aligned.
-- Never install packages, call the network, run git, leave the workspace or touch a database outside module tests. A shell may read/search and run the module's own gates. Otherwise the orchestrator runs gates after your turn.
-- Never bypass a failed gate, weaken tests or invent missing business facts. State the exact blocker.
-
-Finish with a short result and verification. The last line must be:
-HANDOFF: <role-id> - <why>
-or HANDOFF: none - <why>
-Only use a role from the Session team, never yourself. Do not hand off unfinished work assigned to you.`;
-
-export interface InstructionContext {
-	readonly moduleId: string;
-	readonly modulePath: string;
-	readonly sessionKind: 'new-module' | 'edit-module';
-	readonly blueprint: string;
-	readonly allowedPaths: readonly string[];
-	readonly notes?: readonly string[];
-	/* Exactly one selected skill, not the discovery catalog. */
-	readonly skill?: string | null;
-	/* One line per specialist available for the handoff line, as "id: purpose". */
-	readonly team?: readonly string[];
-}
-
-export function composeSessionFacts(context: InstructionContext): string {
-	const lines = [
-		'Session',
-		`- Target module: ${context.moduleId}`,
-		`- Module directory in this workspace: ${context.modulePath}`,
-		`- Session kind: ${context.sessionKind === 'new-module' ? 'new module; author its specification first, then wait for operator approval of the exact spec hash before implementation' : 'change to an existing module; author its spec delta first, then wait for operator approval of the exact spec hash before implementation'}`,
-		`- Blueprint: ${context.blueprint}`,
-		`- Paths you may write: ${context.allowedPaths.join(', ')}`,
-	];
-	if (context.skill) {
-		lines.push(`- Task skill: reference/skills/${context.skill}/SKILL.md`);
-	} else {
-		lines.push(
-			'- No matching task skill is installed. Follow your role and inspect the owning code; do not load unrelated skills.',
-		);
-	}
-	for (const note of context.notes ?? []) lines.push(`- ${note}`);
-	if (context.team && context.team.length > 0) {
-		lines.push(
-			'',
-			'Team you can hand off to',
-			...context.team.map((mate) => `- ${mate}`),
-		);
-	}
-	return lines.join('\n');
-}

package/packages/coding-agent/src/roles/defaults.ts

@@ -1,134 +0,0 @@
-/* GENERATED from .ai/agents/sandbox/*.md by
-   "pnpm --filter @flowdular/sdk/coding-agent sync-roles". Edit the markdown
-   documents, then regenerate; do not edit this file by hand. */
-
-export interface AgentRoleDefinition {
-	readonly id: string;
-	readonly name: string;
-	readonly purpose: string;
-	/* Globs relative to the module directory of the session. */
-	readonly allowedPaths: readonly string[];
-	readonly gates: readonly string[];
-	readonly handoff: readonly string[];
-	readonly instruction: string;
-}
-
-/* Specialists with disjoint ownership. The orchestrator routes a turn to
-   exactly one of them, so a change always has a single accountable role. */
-export const DEFAULT_AGENT_ROLES: readonly AgentRoleDefinition[] = [
-	{
-		id: 'agentic-engineer',
-		name: 'Agentic engineer',
-		purpose:
-			'Design the agent-facing surface of a module: registered tools, module-owned business agents, capability ceilings, refusals, and tests.',
-		allowedPaths: [
-			'spec/**',
-			'src/agent/**',
-			'src/platform.ts',
-			'tests/**',
-			'package.json',
-			'module.json',
-		],
-		gates: [
-			'spec-schema',
-			'module-schema',
-			'dependencies',
-			'typecheck',
-			'tests',
-		],
-		handoff: ['backend-engineer', 'business-manager'],
-		instruction: `You own module tools, business-agent definitions, capability ceilings and their tests. Use only the Task skill selected under Session. Sandbox specialists are coding roles, never business-agent definitions.
-
-A tool wraps the owning module's public service, using registered API/CLI adapters, trusted context.tenantId, bounded input/output and service validation. It never receives a database, filesystem or shell. Register tools and definitions only during createServerComposition. Preserve the rest of that backend-owned file.
-
-The allowed tool list is a maximum. Effective authority also requires tenant binding, invocation grants, registered permissions, the actor's saved ceiling and live authorization. Prove denial through the harness and prove that it writes nothing. Instructions and procedures cannot grant access.
-
-Module-owned agents require a tenant provider/model binding, retained definition revisions and an exact tool ceiling. Never pin provider credentials or use wildcard tools. Procedures stored by agents.core are business data, unrelated to coding skills.
-
-If the requested surface needs a missing endpoint/service, hand off to backend. If a permission or acceptance scenario is missing, hand off to the business manager for a spec delta and renewed approval. Never edit another module or platform package from this session.`,
-	},
-	{
-		id: 'backend-engineer',
-		name: 'Backend engineer',
-		purpose:
-			'Implement the server: ACL constants, endpoints, services, portable repositories, runtime, and dialect-explicit schema.',
-		allowedPaths: [
-			'src/acl/**',
-			'src/api/**',
-			'src/server/**',
-			'src/services/**',
-			'src/domain/**',
-			'src/platform.ts',
-			'src/index.ts',
-			'migrations/**',
-			'tests/**',
-			'module.json',
-			'package.json',
-		],
-		gates: ['module-schema', 'dependencies', 'typecheck', 'tests', 'format'],
-		handoff: ['frontend-engineer', 'agentic-engineer'],
-		instruction: `You own the module's server and persistence. Use only the Task skill selected under Session. Read the owning implementation and copy the relevant shape from reference/example-module; reference/adapter-module is the smallest database-backed example.
-
-The orchestrator scaffolds new modules after exact-hash approval. Extend that skeleton with the approved fields, validation, domain behavior and endpoints. Keep driver details out of the async business repository port. Acquire a short migration lease, release it, then retain a runtime lease; initialization and disposal must be awaited.
-
-Permission constants equal the approved spec. All tenant reads and writes use tenant transactions, explicit predicates and forced RLS. Normalize PostgreSQL integer results and driver errors at the repository boundary.
-
-Test observable behavior: successful operations, validation bounds, 401/403, uniqueness, replay and two-tenant isolation. Use the shared test provider so the same suite runs on PGlite and server PostgreSQL. Never use an owner connection to bypass a failing runtime test.
-
-Leave client files to the frontend engineer and tools/business-agent definitions to the agentic engineer. If their required service surface is missing, finish it here before handing off. Do not change permissions or business requirements without renewed spec approval.`,
-	},
-	{
-		id: 'business-manager',
-		name: 'Business manager',
-		purpose:
-			'Turn a business problem into a schema-valid module specification with acceptance scenarios.',
-		allowedPaths: ['spec/**', 'translations/**'],
-		gates: ['spec-schema'],
-		handoff: ['backend-engineer', 'ux-designer'],
-		instruction: `You own specification decisions and locale terminology, never implementation. Use only the Task skill selected under Session. Consult reference/packages/contracts/schemas/module-spec.schema.json and reference/example-module/spec/module.yaml when writing the spec.
-
-For an edit, compare against base/modules/<dir>/spec/module.yaml and make the smallest delta covering the brief. Start new specs as draft; change an existing approved spec to draft or in-review before editing requirements. Never set approved: only the operator records approval of the exact hash. Later edits invalidate it.
-
-State actors, records, ownership, permissions, uniqueness, failure behavior and observable acceptance scenarios. Do not invent business facts. Include success, denial and cross-tenant cases. The schema rejects unknown keys: express navigation and failure decisions inside invariants and acceptanceScenarios.
-
-Put the primary entity's read/manage permissions first: the scaffold builds that entity, while later permissions only become constants. Capability and dependency declarations must describe the approved module, not guessed future work. Define matching terminology for each declared locale.
-
-Do not write TypeScript, module.json or package.json. Hand a complete specification to backend or UX, explicitly noting that implementation awaits exact-hash approval. If a business decision is missing, end with HANDOFF: none and the question.`,
-	},
-	{
-		id: 'frontend-engineer',
-		name: 'Frontend engineer',
-		purpose:
-			'Implement the client: contribution, views, forms, state, and API calls.',
-		allowedPaths: ['src/client/**', 'tests/**', 'package.json'],
-		gates: ['dependencies', 'typecheck', 'tests', 'format'],
-		handoff: ['backend-engineer', 'ux-designer'],
-		instruction: `You own src/client: contributions, screens, forms, state and API calls. Use only the Task skill selected under Session and consult reference/design-system.md for visual changes. Extend the scaffold and copy reference/example-module/src/client where needed.
-
-Keep fetch calls in api.ts, pass the contribution's CSRF token into mutations, use same-origin credentials and JSON content type. Handle error envelopes. Stores belong to a component instance, never a module singleton shared across tenants.
-
-Use the canonical createClientContribution entry. Navigation must point at an existing view; widgets use registered shell slots. Missing scopes hide actions, but server authorization remains authoritative. Keep server dependencies out of client imports.
-
-Records own the page, with create/edit in a Drawer. Reuse TableCard and Table, including widths, loading and empty states. Use translated copy, all five states, and no hardcoded design values. Inspect the rendered screen before handoff.
-
-For TSRX, loop keys can read only the loop item: precompute a key on each item if it needs props or local state. Test pure mapping/filtering logic in .ts helpers. Ask the backend engineer for missing endpoints or fields, or UX for an unresolved screen decision; do not invent either.`,
-	},
-	{
-		id: 'ux-designer',
-		name: 'UX designer',
-		purpose:
-			'Design the screens, their states, and their copy on the shared design system.',
-		allowedPaths: ['src/client/**'],
-		gates: ['typecheck', 'format'],
-		handoff: ['frontend-engineer', 'business-manager'],
-		instruction: `You own screen structure, states and copy in src/client. Use only the Task skill selected under Session, reference/design-system.md and the relevant shared component source. reference/example-module/src/client/CatalogView.tsrx is the screen example.
-
-Reshape the existing scaffold into a typechecking view and Drawer form. Leave fetch, api.ts and data wiring to the frontend engineer. Use readonly typed props and real domain types, not fabricated records presented as working behavior.
-
-Specify loading, empty, error, populated and denied states. Use TableCard with a one-line head, search and a Filters dropdown; records retain the page width. A form never sits beside a record table. FormField labels each field once, fields top-align, and long values stay inside their container.
-
-Use shared primitives and tokens. A missing primitive may be a small module-local component, flagged for possible promotion. Do not restyle ui-* classes. Reference existing translation keys; hand missing locale terms to the business manager because translations/ is outside your write scope.
-
-Inspect the rendered result for overflow, alignment and duplicate labels. Hand the skeleton to frontend for data wiring, or ask the business manager for missing business decisions.`,
-	},
-];

package/packages/coding-agent/src/roles/handoff.ts

@@ -1,41 +0,0 @@
-export interface HandoffDeclaration {
-	/* The role that should take the next turn, or null when the specialist
-	   reports the work as finished. */
-	readonly role: string | null;
-	readonly reason: string;
-}
-
-const LINE = /^handoff\s*:\s*(.*)$/i;
-const PARTS = /^([a-z][a-z0-9_ -]*?)(?:\s*(?:[:|\u2013\u2014]|\s-)\s*(.*))?$/i;
-const DECORATION = /[`*_>#]/g;
-
-/* Models write the role as an id, a display name, or with a trailing full
-   stop. All of them name the same specialist, so the id is normalized before
-   the orchestrator compares it with the registered roles. */
-function normalizeRole(value: string): string {
-	return value
-		.trim()
-		.toLowerCase()
-		.replace(/[\s_]+/g, '-');
-}
-
-/* Every role ends its final message with one handoff line, so the orchestrator
-   knows who continues without asking a model to summarize the state again. The
-   last line wins: a specialist that quotes the format while explaining itself
-   cannot redirect the routing. */
-export function parseHandoff(text: string): HandoffDeclaration | null {
-	const lines = text.split('\n');
-	for (let index = lines.length - 1; index >= 0; index -= 1) {
-		const line = lines[index]!.replace(DECORATION, '').trim();
-		const match = LINE.exec(line);
-		if (!match) continue;
-		const parts = PARTS.exec(match[1]!.replace(/[.!]+$/, '').trim());
-		if (!parts) continue;
-		const role = normalizeRole(parts[1]!);
-		return {
-			role: role === 'none' ? null : role,
-			reason: (parts[2] ?? '').trim().slice(0, 240),
-		};
-	}
-	return null;
-}

package/packages/coding-agent/src/roles/registry.ts

@@ -1,156 +0,0 @@
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { parse as parseYaml } from 'yaml';
-import { CodingAgentError } from '../types.ts';
-import {
-	SANDBOX_AGENT_CONTRACT,
-	composeSessionFacts,
-	type InstructionContext,
-} from './contract.ts';
-import { DEFAULT_AGENT_ROLES, type AgentRoleDefinition } from './defaults.ts';
-
-export const SANDBOX_ROLE_DIRECTORY = '.ai/agents/sandbox';
-
-interface RoleFrontMatter {
-	readonly id?: string;
-	readonly name?: string;
-	readonly purpose?: string;
-	readonly allowedPaths?: readonly string[];
-	readonly gates?: readonly string[];
-	readonly handoff?: readonly string[];
-}
-
-function stringList(value: unknown, field: string): readonly string[] {
-	if (
-		!Array.isArray(value) ||
-		value.some((entry) => typeof entry !== 'string')
-	) {
-		throw new CodingAgentError(
-			'INVALID_ROLE',
-			`Role field ${field} must be a list of strings.`,
-		);
-	}
-	return value as readonly string[];
-}
-
-export function parseRoleDocument(source: string): AgentRoleDefinition {
-	const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(source);
-	if (!match) {
-		throw new CodingAgentError(
-			'INVALID_ROLE',
-			'A role document needs YAML front matter followed by its instruction.',
-		);
-	}
-	const meta = (parseYaml(match[1]!) ?? {}) as RoleFrontMatter;
-	const instruction = match[2]!.trim();
-	if (!meta.id || !meta.name || !meta.purpose || !instruction) {
-		throw new CodingAgentError(
-			'INVALID_ROLE',
-			'A role document needs id, name, purpose, and an instruction body.',
-		);
-	}
-	return {
-		id: meta.id,
-		name: meta.name,
-		purpose: meta.purpose,
-		allowedPaths: stringList(meta.allowedPaths ?? [], 'allowedPaths'),
-		gates: stringList(meta.gates ?? [], 'gates'),
-		handoff: stringList(meta.handoff ?? [], 'handoff'),
-		instruction,
-	};
-}
-
-function yamlScalar(value: string): string {
-	return `'${value.replace(/'/g, "''")}'`;
-}
-
-export function renderRoleDocument(role: AgentRoleDefinition): string {
-	const front = [
-		'---',
-		`id: ${role.id}`,
-		`name: ${yamlScalar(role.name)}`,
-		`purpose: ${yamlScalar(role.purpose)}`,
-		'allowedPaths:',
-		...role.allowedPaths.map((path) => `  - ${yamlScalar(path)}`),
-		'gates:',
-		...role.gates.map((gate) => `  - ${gate}`),
-		'handoff:',
-		...role.handoff.map((handoff) => `  - ${handoff}`),
-		'---',
-		'',
-	].join('\n');
-	return `${front}${role.instruction}\n`;
-}
-
-/* Roles are workspace configuration. Bundled defaults apply until a workspace
-   writes its own under .ai/agents/sandbox, which then wins by id. */
-export async function loadAgentRoles(
-	workspaceRoot: string,
-): Promise<readonly AgentRoleDefinition[]> {
-	const roles = new Map(DEFAULT_AGENT_ROLES.map((role) => [role.id, role]));
-	const directory = join(workspaceRoot, SANDBOX_ROLE_DIRECTORY);
-	let entries: readonly string[];
-	try {
-		entries = await readdir(directory);
-	} catch {
-		return [...roles.values()];
-	}
-	for (const entry of entries) {
-		if (!entry.endsWith('.md')) continue;
-		const role = parseRoleDocument(
-			await readFile(join(directory, entry), 'utf8'),
-		);
-		roles.set(role.id, role);
-	}
-	return [...roles.values()].sort((left, right) =>
-		left.id.localeCompare(right.id),
-	);
-}
-
-export async function materializeAgentRoles(
-	workspaceRoot: string,
-	roles: readonly AgentRoleDefinition[] = DEFAULT_AGENT_ROLES,
-): Promise<readonly string[]> {
-	const directory = join(workspaceRoot, SANDBOX_ROLE_DIRECTORY);
-	await mkdir(directory, { recursive: true });
-	const written: string[] = [];
-	for (const role of roles) {
-		const path = join(directory, `${role.id}.md`);
-		await writeFile(path, renderRoleDocument(role), 'utf8');
-		written.push(`${SANDBOX_ROLE_DIRECTORY}/${role.id}.md`);
-	}
-	return written;
-}
-
-export function findRole(
-	roles: readonly AgentRoleDefinition[],
-	id: string,
-): AgentRoleDefinition {
-	const role = roles.find((candidate) => candidate.id === id);
-	if (!role) {
-		throw new CodingAgentError('UNKNOWN_ROLE', `Unknown agent role: ${id}`);
-	}
-	return role;
-}
-
-export function composeInstruction(
-	role: AgentRoleDefinition,
-	context: InstructionContext,
-): string {
-	return [
-		SANDBOX_AGENT_CONTRACT,
-		'',
-		`Role: ${role.name}`,
-		role.purpose,
-		'',
-		role.instruction,
-		'',
-		composeSessionFacts({
-			...context,
-			allowedPaths:
-				context.allowedPaths.length > 0
-					? context.allowedPaths
-					: role.allowedPaths,
-		}),
-	].join('\n');
-}

package/packages/coding-agent/src/roles/skills.ts

@@ -1,72 +0,0 @@
-export interface TaskSkillContext {
-	readonly role: string;
-	readonly sessionKind: 'new-module' | 'edit-module';
-	readonly blueprint: string;
-	readonly task: string;
-	readonly available: readonly string[];
-}
-
-/* A single deterministic selection. Discovery is not injected into the prompt.
-   Only skills this specialist can use are eligible for an explicit $skill. */
-const ROLE_SKILLS: Readonly<Record<string, readonly string[]>> = {
-	'business-manager': ['module-new', 'module-update'],
-	'backend-engineer': [
-		'module-new',
-		'module-update',
-		'database-adapter',
-		'migration-authoring',
-		'bug-hunt',
-		'test-hardening',
-		'auth-security-review',
-		'perf-audit',
-	],
-	'frontend-engineer': [
-		'ux-design',
-		'module-update',
-		'variables',
-		'workflow-development',
-		'bug-hunt',
-		'test-hardening',
-	],
-	'ux-designer': ['ux-design'],
-	'agentic-engineer': [
-		'agent-tool-design',
-		'business-agent-design',
-		'workflow-development',
-		'variables',
-		'test-hardening',
-	],
-};
-
-export function selectTaskSkill(context: TaskSkillContext): string | null {
-	// Review is read-only and is available to custom registered specialists too.
-	const eligible = [...(ROLE_SKILLS[context.role] ?? []), 'auto-review'];
-	const available = new Set(context.available);
-	const installed = (skill: string) =>
-		eligible.includes(skill) && available.has(skill);
-	const explicit = [...context.task.matchAll(/\$([a-z][a-z0-9-]*)\b/g)]
-		.map((match) => match[1]!)
-		.find(installed);
-	if (explicit) return explicit;
-	const blueprint = context.blueprint.split('@')[0];
-	const focused =
-		blueprint === 'add-migration'
-			? 'migration-authoring'
-			: blueprint === 'bug-fix'
-				? 'bug-hunt'
-				: null;
-	if (focused && installed(focused)) return focused;
-	const moduleSkill =
-		context.sessionKind === 'new-module' ? 'module-new' : 'module-update';
-	const defaultSkill =
-		context.role === 'agentic-engineer'
-			? /\b(workflow|pipeline|dag)\b/i.test(context.task)
-				? 'workflow-development'
-				: /\b(defineAgent|business agent|agent biznesowy)\b/i.test(context.task)
-					? 'business-agent-design'
-					: 'agent-tool-design'
-			: context.role === 'frontend-engineer' || context.role === 'ux-designer'
-				? 'ux-design'
-				: moduleSkill;
-	return installed(defaultSkill) ? defaultSkill : null;
-}

package/packages/coding-agent/src/roles/sync.ts

@@ -1,88 +0,0 @@
-import { readFile, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { AgentRoleDefinition } from './defaults.ts';
-import { parseRoleDocument } from './registry.ts';
-
-/* Prettier escapes markdown punctuation in the role documents (ui-\* for
-   ui-*). The escape is a rendering detail of the document, not part of the
-   instruction a model should read, so it is removed when the document becomes
-   the bundled default. */
-export function normalizeRoleDocument(
-	role: AgentRoleDefinition,
-): AgentRoleDefinition {
-	return {
-		...role,
-		instruction: role.instruction.replace(/\\([*_`#[\]])/g, '$1'),
-	};
-}
-
-export async function loadRoleDocuments(
-	directory: string,
-): Promise<readonly AgentRoleDefinition[]> {
-	const roles: AgentRoleDefinition[] = [];
-	for (const entry of (await readdir(directory)).sort()) {
-		if (!entry.endsWith('.md')) continue;
-		roles.push(
-			normalizeRoleDocument(
-				parseRoleDocument(await readFile(join(directory, entry), 'utf8')),
-			),
-		);
-	}
-	return roles.sort((left, right) => left.id.localeCompare(right.id));
-}
-
-function literal(value: string): string {
-	return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
-}
-
-function template(value: string): string {
-	return `\`${value.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${')}\``;
-}
-
-function list(values: readonly string[]): string {
-	return `[${values.map(literal).join(', ')}]`;
-}
-
-/* The bundled defaults are generated from the workspace role documents, so
-   the two never disagree: the markdown is the source, this module is the
-   fallback for a workspace that has not materialized its own copy yet. */
-export function renderDefaultsModule(
-	roles: readonly AgentRoleDefinition[],
-): string {
-	const entries = roles.map((role) =>
-		[
-			'\t{',
-			`\t\tid: ${literal(role.id)},`,
-			`\t\tname: ${literal(role.name)},`,
-			`\t\tpurpose: ${literal(role.purpose)},`,
-			`\t\tallowedPaths: ${list(role.allowedPaths)},`,
-			`\t\tgates: ${list(role.gates)},`,
-			`\t\thandoff: ${list(role.handoff)},`,
-			`\t\tinstruction: ${template(role.instruction)},`,
-			'\t},',
-		].join('\n'),
-	);
-	return [
-		'/* GENERATED from .ai/agents/sandbox/*.md by',
-		'   "pnpm --filter @flowdular/sdk/coding-agent sync-roles". Edit the markdown',
-		'   documents, then regenerate; do not edit this file by hand. */',
-		'',
-		'export interface AgentRoleDefinition {',
-		'\treadonly id: string;',
-		'\treadonly name: string;',
-		'\treadonly purpose: string;',
-		'\t/* Globs relative to the module directory of the session. */',
-		'\treadonly allowedPaths: readonly string[];',
-		'\treadonly gates: readonly string[];',
-		'\treadonly handoff: readonly string[];',
-		'\treadonly instruction: string;',
-		'}',
-		'',
-		'/* Specialists with disjoint ownership. The orchestrator routes a turn to',
-		'   exactly one of them, so a change always has a single accountable role. */',
-		'export const DEFAULT_AGENT_ROLES: readonly AgentRoleDefinition[] = [',
-		...entries,
-		'];',
-		'',
-	].join('\n');
-}