@sdods/agents 0.2.0

package/dist/claude-code/install.d.ts

@@ -0,0 +1,36 @@
+export type CodingAgentTarget = 'claude' | 'codex' | 'all';
+export interface InstallCodingAgentsOptions {
+    for?: CodingAgentTarget;
+    project?: string;
+    env?: string;
+    force?: boolean;
+    /** also write `.mcp.json` for Claude Code (the CLI normally registers MCP via `sdods mcp install`) */
+    mcp?: boolean;
+}
+/**
+ * Set up coding-agent CLIs for an SDODS repo:
+ * - Claude Code: `.claude/agents/sdods-<role>.md` (one subagent per role) + `CLAUDE.md`
+ * - Codex: `AGENTS.md` (Codex reads it as project instructions; roles become sections)
+ * - both: `AGENT.md` and `SKILL.md` with the conventions
+ * Returns the paths written. Existing files are kept unless `force`.
+ */
+export declare function installCodingAgents(rootDir: string, opts?: InstallCodingAgentsOptions): string[];
+/** Backwards-compatible alias: Claude Code files plus `.mcp.json`. */
+export declare function installClaudeCode(rootDir: string, opts?: {
+    project?: string;
+    env?: string;
+    force?: boolean;
+}): string[];
+/** CLAUDE.md: what Claude Code loads automatically. Short pointer plus the rules that matter. */
+export declare function claudeMdContent(opts?: {
+    project?: string;
+    env?: string;
+}): string;
+/** AGENTS.md: Codex reads this as project instructions; roles become sections. */
+export declare function agentsMdContent(opts?: {
+    project?: string;
+    env?: string;
+}): string;
+export declare function agentMdContent(): string;
+export declare function skillMdContent(): string;
+//# sourceMappingURL=install.d.ts.map

package/dist/claude-code/install.js

@@ -0,0 +1,183 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONVENTIONS, ROLE_PROMPTS, installClientConfig } from '@sdods/mcp';
+const TAGLINE = 'SDODS is an automation and orchestration platform with a reusable architecture: BDD for UI, API and hybrid flows.';
+function roleUse(role) {
+    return role === 'planner'
+        ? 'plan tests'
+        : role === 'generator'
+            ? 'write or generate features'
+            : role === 'healer'
+                ? 'fix a failing scenario'
+                : role === 'upgrader'
+                    ? 'update tests after code changes'
+                    : 'review feature files';
+}
+/**
+ * Set up coding-agent CLIs for an SDODS repo:
+ * - Claude Code: `.claude/agents/sdods-<role>.md` (one subagent per role) + `CLAUDE.md`
+ * - Codex: `AGENTS.md` (Codex reads it as project instructions; roles become sections)
+ * - both: `AGENT.md` and `SKILL.md` with the conventions
+ * Returns the paths written. Existing files are kept unless `force`.
+ */
+export function installCodingAgents(rootDir, opts = {}) {
+    const target = opts.for ?? 'all';
+    const written = [];
+    const writeIfMissing = (file, content) => {
+        if (existsSync(file) && !opts.force)
+            return;
+        mkdirSync(join(file, '..'), { recursive: true });
+        writeFileSync(file, content);
+        written.push(file);
+    };
+    if (target === 'claude' || target === 'all') {
+        const agentsDir = join(rootDir, '.claude', 'agents');
+        for (const role of Object.keys(ROLE_PROMPTS)) {
+            const p = ROLE_PROMPTS[role];
+            writeIfMissing(join(agentsDir, `sdods-${role}.md`), `---\nname: sdods-${role}\ndescription: ${p.description} Use when the user asks SDODS to ${roleUse(role)}.\ntools: Read, Glob, Grep, mcp__sdods__*, mcp__playwright__*\n---\n\n${CONVENTIONS}\n\n${p.body}\n`);
+        }
+        writeIfMissing(join(rootDir, 'CLAUDE.md'), claudeMdContent(opts));
+        if (opts.mcp) {
+            const mcp = installClientConfig(rootDir, 'claude', {
+                project: opts.project,
+                env: opts.env,
+                args: ['sdods', 'mcp'],
+            });
+            written.push(mcp.file);
+        }
+    }
+    if (target === 'codex' || target === 'all') {
+        writeIfMissing(join(rootDir, 'AGENTS.md'), agentsMdContent(opts));
+    }
+    writeIfMissing(join(rootDir, 'AGENT.md'), agentMdContent());
+    writeIfMissing(join(rootDir, 'SKILL.md'), skillMdContent());
+    return written;
+}
+/** Backwards-compatible alias: Claude Code files plus `.mcp.json`. */
+export function installClaudeCode(rootDir, opts = {}) {
+    return installCodingAgents(rootDir, { ...opts, for: 'claude', mcp: true });
+}
+function projectFlags(opts) {
+    return `${opts.project ? ` -p ${opts.project}` : ''}${opts.env ? ` -e ${opts.env}` : ''}`;
+}
+/** CLAUDE.md: what Claude Code loads automatically. Short pointer plus the rules that matter. */
+export function claudeMdContent(opts = {}) {
+    return `# CLAUDE.md — SDODS
+
+${TAGLINE} Read \`AGENT.md\` for the mental model and \`SKILL.md\` for the command reference.
+
+## Working in this repo
+
+- Use the SDODS MCP server (\`sdods mcp\`) for anything about projects, features, steps, runs and results — it is registered in \`.mcp.json\` (\`sdods mcp install claude\` re-registers it).
+- Subagents live in \`.claude/agents/sdods-*.md\`: planner, generator, healer, upgrader, reviewer. Delegate matching requests to them.
+- Never edit features/steps/pages directly when acting as an SDODS agent: write a proposal (\`write_proposal\` / \`feature_write\`) and let a person accept it with \`sdods proposals accept <id>\`.
+- Verify with \`sdods lint${projectFlags(opts)}\` and \`sdods run${projectFlags(opts)} -l api\` / \`-l ui -b chromium -t @smoke\` before claiming done.
+
+## Rules
+
+${CONVENTIONS.split('\n').slice(3).join('\n')}
+`;
+}
+/** AGENTS.md: Codex reads this as project instructions; roles become sections. */
+export function agentsMdContent(opts = {}) {
+    const roles = Object.keys(ROLE_PROMPTS)
+        .map((role) => `### sdods-${role}\n\n${ROLE_PROMPTS[role].description}\n\n${ROLE_PROMPTS[role].body}`)
+        .join('\n\n');
+    return `# AGENTS.md — SDODS instructions for Codex
+
+${TAGLINE} This file is read by the OpenAI Codex CLI. \`AGENT.md\` holds the mental model and \`SKILL.md\` the command reference.
+
+## Tools
+
+- The SDODS MCP server is registered as \`sdods\` (\`sdods mcp install codex\` re-registers it in \`~/.codex/config.toml\`); use its tools for projects, features, steps, runs, results, proposals.
+- The bundled Playwright MCP server is registered as \`playwright\` for driving a browser.
+- Commands: \`sdods lint${projectFlags(opts)}\`, \`sdods run${projectFlags(opts)} -l api\`, \`sdods run${projectFlags(opts)} -l ui -b chromium -t @smoke\`, \`sdods steps list${projectFlags(opts)}\`, \`sdods proposals list|show|accept\`.
+
+## Rules
+
+${CONVENTIONS.split('\n').slice(3).join('\n')}
+
+## Roles
+
+Pick the role that matches the request and follow its instructions. Every role only writes proposals; a person accepts them.
+
+${roles}
+`;
+}
+export function agentMdContent() {
+    return `# AGENT.md — SDODS for coding agents
+
+${TAGLINE} This file orients an AI coding assistant working in this repository.
+
+## Mental model
+
+- **Hierarchy**: organization → workspace(s) → project (\`projects/<slug>\`) → module (\`features/<module>/\`). \`sdods.workspace.yaml\` at the root names the org and workspaces; each project has \`sdods.project.yaml\` and \`envs/<env>.yaml\`.
+- **Layers**: \`@ui\`, \`@api\`, \`@hybrid\` scenarios share ONE merged BDD fixture set (\`@sdods/core/fixtures\`). A scenario can seed through the API and assert in the browser.
+- **Processes**: named run recipes (pr-check, nightly-regression, release-gate). \`sdods run --process <name>\`.
+- **Everything is CLI-first**: \`sdods run\`, \`lint\`, \`steps list\`, \`features list\`, \`report\`, \`heal report\`, \`record\`, \`har\`, \`db\`, \`mcp\`, \`agent\`, \`proposals\`, \`serve\`.
+- **Agents never edit the working tree**; they write proposals under \`proposals/<id>/\` that a person accepts with \`sdods proposals accept <id>\`.
+
+## Conventions
+
+${CONVENTIONS.split('\n').slice(3).join('\n')}
+
+## Where things live
+
+| Path | Purpose |
+|---|---|
+| \`packages/contracts\` | schemas, ids, attachment names, scopes (leaf package) |
+| \`packages/core\` | config precedence, registry, fixtures, step library, data, screenshots, heal, recorder, lint, analyze |
+| \`packages/cli\` | the \`sdods\` command |
+| \`packages/db\` | Kysely, SQLite ⇄ Postgres, ingest, insights |
+| \`packages/mcp\` | tool registry, MCP server (stdio + HTTP), proposals, prompts |
+| \`packages/agents\` | LLM adapters, roles, jobs |
+| \`packages/integrations\` | GitHub, Jira |
+| \`packages/server\`, \`packages/web\` | Fastify API and React UI |
+| \`projects/demo-shop\` | reference project and release acceptance suite |
+
+## Verify before you claim done
+
+\`\`\`bash
+bun run typecheck && bun run lint && bun run test
+bun run sdods lint -p <slug>
+bun run sdods run -p <slug> -e <env> -l api
+bun run sdods run -p <slug> -e <env> -l ui -b chromium -t @smoke
+\`\`\`
+`;
+}
+export function skillMdContent() {
+    return `---
+name: sdods
+description: Work inside an SDODS repository — an automation and orchestration platform with a reusable architecture. Use for writing or fixing Gherkin features, page objects, step definitions, project/env yaml, running suites, reading results, and driving the sdods CLI or MCP tools.
+---
+
+# SDODS skill
+
+## Quick reference
+
+| Task | Command |
+|---|---|
+| See projects / hierarchy | \`sdods project list\`, \`sdods workspace tree\` |
+| Resolve config with provenance | \`sdods config show -p <slug> -e <env> --explain\` |
+| Validate features | \`sdods lint -p <slug>\` |
+| Run a slice | \`sdods run -p <slug> -e <env> -l api\` · \`-l ui -b chromium -t @smoke\` · \`--process pr-check\` |
+| Results | \`sdods report --last\`, \`sdods heal report --last\` |
+| Steps available | \`sdods steps list -p <slug>\` |
+| Record / replay | \`sdods record -p <slug> -e <env> --user <role> --name <name>\`, \`sdods har replay --strict\` |
+| Agents | \`sdods agent plan|generate|heal|upgrade|review -p <slug> [--dry-run]\`, \`sdods proposals list|show|accept|reject\` |
+| MCP | \`sdods mcp --project <slug>\`, \`sdods mcp install claude\` |
+
+## Rules
+
+${CONVENTIONS.split('\n').slice(3).join('\n')}
+
+## Writing a scenario (checklist)
+
+1. Pick the module directory under \`features/\` and the module tag.
+2. Tag the Feature: one layer (\`@ui|@api|@hybrid\`) + one suite (\`@smoke|@regression|@sanity\`).
+3. Reuse steps from \`sdods steps list\`; add project steps in \`steps/<module>.steps.ts\` only when needed.
+4. Data through datasets (\`Given I load dataset "users" row 1\`) or \`@user:<role>\`; never literal secrets.
+5. \`sdods lint -p <slug>\` then run the scenario; check before/after screenshots in \`.sdods/runs/<runId>/\`.
+`;
+}
+//# sourceMappingURL=install.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adapter/index.js';
+export * from './roles/index.js';
+export * from './jobs/runner.js';
+export * from './claude-code/install.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './adapter/index.js';
+export * from './roles/index.js';
+export * from './jobs/runner.js';
+export * from './claude-code/install.js';
+//# sourceMappingURL=index.js.map

package/dist/jobs/runner.d.ts

@@ -0,0 +1,80 @@
+import { type ToolContext, type ToolRegistry } from '@sdods/mcp';
+import { type AgentEvent, type LlmAdapter, type Provider } from '../adapter/index.js';
+import { roleTools, type RoleInput, type RoleName } from '../roles/index.js';
+import { type ProfileSettings } from '../adapter/profile.js';
+export type JobStatus = 'queued' | 'running' | 'awaiting_review' | 'completed' | 'failed' | 'cancelled';
+export interface AgentJob {
+    id: string;
+    role: RoleName;
+    project?: string;
+    env?: string;
+    status: JobStatus;
+    provider: Provider;
+    model: string;
+    input: RoleInput;
+    startedAt: string;
+    finishedAt?: string;
+    costUsd?: number;
+    turns?: number;
+    toolCalls?: number;
+    proposalIds: string[];
+    error?: string;
+    resultText?: string;
+    budgetUsd: number;
+    maxTurns: number;
+    dryRun?: boolean;
+    events?: AgentEvent[];
+}
+export interface RunJobOptions {
+    role: RoleName;
+    input: RoleInput;
+    rootDir?: string;
+    provider?: string;
+    model?: string;
+    /** Model server endpoint, for a provider you host yourself. */
+    baseUrl?: string;
+    /** Context window to load a local model with. */
+    contextTokens?: number;
+    maxTurns?: number;
+    budgetUsd?: number;
+    /** auto | full | small — how much of the platform to show the model. */
+    profile?: string;
+    /** Force the browser server on or off for a role that would otherwise follow the profile. */
+    browser?: boolean;
+    dryRun?: boolean;
+    adapter?: LlmAdapter;
+    registry?: ToolRegistry;
+    onEvent?: (e: AgentEvent) => void;
+    signal?: AbortSignal;
+    keepEvents?: boolean;
+}
+export declare const JOBS_DIR = ".sdods/agent-jobs";
+export declare class JobJournal {
+    readonly dir: string;
+    constructor(rootDir: string);
+    save(job: AgentJob): void;
+    get(id: string): AgentJob | undefined;
+    list(limit?: number): AgentJob[];
+}
+/**
+ * Build the prompt/tool set for a role without running (used by --dry-run and tests).
+ *
+ * Asynchronous because grounding the prompt in the project's real step patterns means asking the
+ * project for them, which compiles it. The result is cached, so the second call is free.
+ */
+export declare function prepareJob(o: RunJobOptions): Promise<{
+    job: AgentJob;
+    ctx: ToolContext;
+    registry: ToolRegistry;
+    system: string;
+    prompt: string;
+    tools: ReturnType<typeof roleTools>;
+    adapter: LlmAdapter;
+    mcpServers: Record<string, any>;
+    /** True for the roles whose work is looking at the application. */
+    needsBrowser: boolean;
+    /** Which menu the model was given, and why. */
+    profile: ProfileSettings;
+}>;
+export declare function runJob(o: RunJobOptions): Promise<AgentJob>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/jobs/runner.js

@@ -0,0 +1,197 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { newId } from '@sdods/contracts';
+import { ProposalStore, buildToolContext, createRegistry, findRepoRoot, readYaml, } from '@sdods/mcp';
+import { createAdapter, } from '../adapter/index.js';
+import { ROLES, rolePrompt, roleSystemPrompt, roleTools, } from '../roles/index.js';
+import { stepVocabulary } from '../roles/steps.js';
+import { resolveProfile } from '../adapter/profile.js';
+export const JOBS_DIR = '.sdods/agent-jobs';
+export class JobJournal {
+    dir;
+    constructor(rootDir) {
+        this.dir = join(rootDir, JOBS_DIR);
+    }
+    save(job) {
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(join(this.dir, `${job.id}.json`), JSON.stringify(job, null, 2));
+    }
+    get(id) {
+        const f = join(this.dir, `${id}.json`);
+        return existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : undefined;
+    }
+    list(limit = 50) {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => JSON.parse(readFileSync(join(this.dir, f), 'utf8')))
+            .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+            .slice(0, limit);
+    }
+}
+/**
+ * Build the prompt/tool set for a role without running (used by --dry-run and tests).
+ *
+ * Asynchronous because grounding the prompt in the project's real step patterns means asking the
+ * project for them, which compiles it. The result is cached, so the second call is free.
+ */
+export async function prepareJob(o) {
+    const rootDir = o.rootDir ?? findRepoRoot();
+    const yaml = o.input.project
+        ? readYaml(join(rootDir, process.env.SDODS_PROJECTS_DIR ?? 'projects', o.input.project, 'sdods.project.yaml'))
+        : undefined;
+    const def = ROLES[o.role];
+    const provider = o.dryRun ? 'fake' : o.provider;
+    const adapter = o.adapter ??
+        createAdapter({
+            provider,
+            model: o.model ?? yaml?.agents?.models?.[o.role] ?? yaml?.agents?.models?.default,
+            baseUrl: o.baseUrl ?? yaml?.agents?.local?.baseUrl,
+            contextTokens: o.contextTokens ?? yaml?.agents?.local?.contextTokens,
+            temperature: yaml?.agents?.local?.temperature,
+            timeoutMs: yaml?.agents?.local?.requestTimeoutMs,
+            rootDir,
+            project: o.input.project,
+            env: o.input.env,
+            onAutoDetect: (p, reason) => o.onEvent?.({ type: 'status', message: `adapter auto-selected: ${p} (${reason})` }),
+        }, yaml?.agents?.provider);
+    const registry = o.registry ?? createRegistry();
+    const ctx = buildToolContext({
+        rootDir,
+        caps: 'all',
+        project: o.input.project,
+        env: o.input.env,
+        onProgress: (p) => o.onEvent?.({ type: 'status', message: p.message ?? '' }),
+    });
+    // The profile decides how much of the platform the model is shown.
+    const profile = resolveProfile({
+        configured: (o.profile ?? yaml?.agents?.profile),
+        provider: adapter.provider,
+        model: o.model ?? yaml?.agents?.models?.[o.role] ?? adapter.defaultModel,
+        baseUrl: o.baseUrl ?? yaml?.agents?.local?.baseUrl,
+        contextTokens: o.contextTokens ?? yaml?.agents?.local?.contextTokens,
+    });
+    const tools = roleTools(o.role, registry, ctx, profile.profile);
+    const vocabulary = await stepVocabulary({
+        registry,
+        ctx,
+        project: o.input.project,
+        focus: [o.input.goal, o.input.plan, o.input.spec].filter(Boolean).join('\n').slice(0, 2000),
+        limit: profile.stepVocabularyLimit,
+    });
+    const system = roleSystemPrompt(o.role, o.input, vocabulary.selected, profile.profile);
+    const prompt = rolePrompt(o.role, o.input, profile.profile);
+    const mcpServers = {};
+    for (const [name, s] of Object.entries(yaml?.mcp?.servers ?? {})) {
+        if (s.enabled === false || name === 'playwright')
+            continue;
+        const env = Object.fromEntries(Object.entries(s.envFrom ?? {}).map(([k, v]) => [k, process.env[v] ?? '']));
+        const headers = Object.fromEntries(Object.entries(s.headersFrom ?? {}).map(([k, v]) => [k, process.env[v] ?? '']));
+        mcpServers[name] = {
+            transport: s.transport ?? 'stdio',
+            command: s.command,
+            args: s.args,
+            url: s.url,
+            env,
+            headers,
+            allowedTools: s.allowedTools,
+        };
+    }
+    const job = {
+        id: `${new Date().toISOString().slice(0, 19).replace(/[-:T]/g, '')}-${o.role}-${newId().slice(-6)}`,
+        role: o.role,
+        project: o.input.project,
+        env: o.input.env,
+        status: 'queued',
+        provider: adapter.provider,
+        model: o.model ??
+            yaml?.agents?.models?.[o.role] ??
+            yaml?.agents?.models?.default ??
+            adapter.defaultModel,
+        input: o.input,
+        startedAt: new Date().toISOString(),
+        proposalIds: [],
+        budgetUsd: o.budgetUsd ??
+            yaml?.agents?.budgetUsd?.[o.role] ??
+            yaml?.agents?.budgetUsd?.default ??
+            def.defaults.budgetUsd,
+        maxTurns: o.maxTurns ?? yaml?.agents?.maxTurns?.[o.role] ?? def.defaults.maxTurns,
+        dryRun: o.dryRun,
+    };
+    return {
+        job,
+        ctx,
+        registry,
+        system,
+        prompt,
+        tools,
+        adapter,
+        mcpServers,
+        needsBrowser: def.needsBrowser,
+        profile,
+    };
+}
+export async function runJob(o) {
+    const prep = await prepareJob(o);
+    const { job, ctx, adapter, system, prompt, tools, mcpServers, needsBrowser, profile } = prep;
+    const journal = new JobJournal(ctx.rootDir);
+    const before = new Set(new ProposalStore(ctx.rootDir).list().map((p) => p.id));
+    const events = [];
+    job.status = 'running';
+    journal.save(job);
+    o.onEvent?.({
+        type: 'status',
+        message: `profile ${profile.profile} (${profile.reason}) · ${tools.length} tool(s)`,
+    });
+    try {
+        const result = await adapter.runAgent({
+            system,
+            prompt,
+            tools,
+            mcpServers,
+            // A browser role keeps its browser unless the profile (or the caller) says otherwise.
+            needsBrowser: needsBrowser && (o.browser ?? profile.attachBrowser),
+            maxToolCallsPerTurn: profile.maxToolCallsPerTurn,
+            firstTurnToolChoice: profile.firstTurnToolChoice,
+            maxBridgedTools: profile.maxBridgedTools,
+            recoverTextToolCalls: profile.recoverTextToolCalls,
+            maxTokens: profile.maxTokens,
+            model: job.model,
+            maxTurns: profile.maxTurns ? Math.min(profile.maxTurns, job.maxTurns) : job.maxTurns,
+            maxBudgetUsd: job.budgetUsd,
+            cwd: ctx.rootDir,
+            signal: o.signal,
+            onEvent: (e) => {
+                if (o.keepEvents)
+                    events.push(e);
+                o.onEvent?.(e);
+            },
+        });
+        job.costUsd = result.costUsd;
+        job.turns = result.turns;
+        job.toolCalls = result.toolCalls;
+        job.resultText = result.text;
+        job.proposalIds = new ProposalStore(ctx.rootDir)
+            .list()
+            .map((p) => p.id)
+            .filter((id) => !before.has(id));
+        job.status = result.isError
+            ? 'failed'
+            : job.proposalIds.length
+                ? 'awaiting_review'
+                : 'completed';
+        if (result.isError)
+            job.error = result.stopReason;
+    }
+    catch (e) {
+        job.status = o.signal?.aborted ? 'cancelled' : 'failed';
+        job.error = e.message;
+    }
+    job.finishedAt = new Date().toISOString();
+    if (o.keepEvents)
+        job.events = events;
+    journal.save(job);
+    return job;
+}
+//# sourceMappingURL=runner.js.map

package/dist/roles/index.d.ts

@@ -0,0 +1,50 @@
+import { ROLE_PROMPTS, type RoleName } from '@sdods/mcp/prompts';
+import { type ToolContext, type ToolRegistry } from '@sdods/mcp';
+import type { ProfileName } from '../adapter/profile.js';
+export type { RoleName };
+export { ROLE_PROMPTS };
+export interface RoleInput {
+    project?: string;
+    env?: string;
+    goal?: string;
+    plan?: string;
+    scenario?: string;
+    runId?: string;
+    diff?: string;
+    files?: string[];
+    spec?: string;
+}
+export interface RoleDefinition {
+    role: RoleName;
+    /** which tools the role may call (name prefixes) */
+    toolPrefixes: string[];
+    /**
+     * The tools this role keeps under the small profile — named exactly, not by prefix, because
+     * the point is a menu a 7B model can read. Ordered by when the role should reach for them.
+     */
+    smallTools: string[];
+    needsBrowser: boolean;
+    /** budget defaults when the project yaml does not set them */
+    defaults: {
+        maxTurns: number;
+        budgetUsd: number;
+    };
+    buildPrompt(input: RoleInput): string;
+    /**
+     * The same request for a small model: one action, and only tools the small profile actually
+     * has. The full prompts name a sequence of three calls, which a 7B model answers by describing
+     * all three instead of making the first.
+     */
+    buildSmallPrompt(input: RoleInput): string;
+}
+export declare const ROLES: Record<RoleName, RoleDefinition>;
+/** The user-facing request for a role, in the shape the profile can act on. */
+export declare function rolePrompt(role: RoleName, input: RoleInput, profile?: ProfileName): string;
+export declare function roleSystemPrompt(role: RoleName, input: RoleInput, steps?: string[], profile?: ProfileName): string;
+/**
+ * Tools visible to a role. The full profile filters by prefix; the small profile takes the
+ * role's named allowlist, in its declared order, so the model reads a short list of things it is
+ * expected to do rather than a catalogue.
+ */
+export declare function roleTools(role: RoleName, registry: ToolRegistry, ctx: ToolContext, profile?: ProfileName): import("@sdods/mcp").AgentSdkToolDef[];
+//# sourceMappingURL=index.d.ts.map