@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/src/qa/tools.js

@@ -0,0 +1,301 @@
+import { clipText } from '../text.js';
+import { getQaOrchestrator } from './orchestrator/QaOrchestrator.js';
+import { createQaAuthorizer } from './qa-authorize.js';
+import { getQaPtyManager } from './runtime/PtyManager.js';
+const RESULT_LIMIT = 25;
+const ERROR_LIMIT = 20;
+function compactResult(result) {
+    return {
+        id: result.id, category: result.category, status: result.status, durationMs: result.durationMs,
+        summary: result.summary.slice(0, 400),
+        ...(result.errors?.length ? { errors: result.errors.slice(0, ERROR_LIMIT).map(issue => ({ file: issue.file, line: issue.line, severity: issue.severity, message: issue.message.slice(0, 300), code: issue.code })) } : {}),
+        ...(result.importantOutput?.length ? { importantOutput: result.importantOutput.slice(0, 15) } : {}),
+        ...(result.logRef ? { logRef: result.logRef } : {}),
+        ...(result.repairExhausted ? { repairExhausted: true } : {}),
+    };
+}
+function reportText(report) {
+    const lines = report.results.map(result => `${result.id}: ${result.status.toUpperCase()} — ${result.summary}`);
+    const gate = report.gate ? `\nMerge gate (${report.gate.steps.join(', ')}): ${report.gate.verdict.toUpperCase()}` : '';
+    return clipText(`QA run ${report.runId}: ${report.verdict.toUpperCase()}.${gate}\n${lines.join('\n')}`, 24_000);
+}
+function reportOutput(report) {
+    return clipText(JSON.stringify({
+        runId: report.runId, verdict: report.verdict, fingerprint: report.fingerprint,
+        changedFiles: report.changedFiles.slice(0, 100),
+        ...(report.gate ? { gate: report.gate } : {}),
+        results: report.results.slice(0, RESULT_LIMIT).map(compactResult),
+        summary: reportText(report),
+    }), 24_000);
+}
+function reportEventOutput(output) {
+    try {
+        const parsed = JSON.parse(output);
+        return JSON.stringify({ runId: parsed.runId, verdict: parsed.verdict, results: parsed.results?.map(result => ({ id: result.id, status: result.status })) });
+    }
+    catch {
+        return output.slice(0, 500);
+    }
+}
+function validateStringArray(value, name, max) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length > max || value.some(item => typeof item !== 'string' || !item || item.length > 1024))
+        throw new Error(`${name} must be an array of at most ${max} nonempty strings`);
+    return value;
+}
+function assertTerminalApplication(command) {
+    const trimmed = command.trim();
+    const first = /^(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(trimmed)?.slice(1).find(Boolean)?.toLowerCase() ?? '';
+    const executable = first.replace(/^.*[\\/]/, '');
+    if (['powershell', 'powershell.exe', 'pwsh', 'pwsh.exe'].includes(executable)) {
+        if (/\s-noexit(?:\s|$)/i.test(trimmed) || !/\s-(?:command|encodedcommand|file)(?:\s|$)/i.test(trimmed)) {
+            throw new Error('qa.terminal must launch the application under test, not an idle PowerShell session');
+        }
+    }
+    if (['cmd', 'cmd.exe'].includes(executable)) {
+        if (/\s\/k(?:\s|$)/i.test(trimmed) || !/\s\/c(?:\s|$)/i.test(trimmed)) {
+            throw new Error('qa.terminal must launch the application under test, not an idle cmd session');
+        }
+    }
+    if (['bash', 'bash.exe', 'sh', 'zsh', 'fish'].includes(executable)) {
+        if (/\s-i(?:\s|$)/i.test(trimmed) || !/\s-c(?:\s|$)/i.test(trimmed)) {
+            throw new Error('qa.terminal must launch the application under test, not an idle shell session');
+        }
+    }
+}
+/** The LLM-facing QA tools. All command execution is permission-gated. */
+export function createQaTools() {
+    return [
+        {
+            name: 'qa.inspect_project',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Report the derived QA profile for this workspace: language, framework, package manager, the lint/typecheck/unit/build/e2e commands QA will run, detected runtime tools, current changed files and their classification, and any .andorra/qa.yaml validation error. Read-only; runs no commands.',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+            execute: async (_args, context) => {
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const summary = await orchestrator.profileSummary(context.signal);
+                const snapshot = await orchestrator.changeSnapshot(context.signal);
+                return `${summary}\nchanged files (${snapshot.changedFiles.length}): ${snapshot.changedFiles.slice(0, 60).join(', ') || 'none'}\nclassification: ${Object.entries(snapshot.classification).filter(([, active]) => active).map(([name]) => name).join(', ') || 'none'}`;
+            },
+        },
+        {
+            name: 'qa.fast',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Run the fast QA pipeline over the current working tree: lint, typecheck, unit tests related to changed files, then automated diff review and secret scan (redacted). Set includeBuild when the build matters (packaging or build-config changes). After any fix, re-run this before trusting the result.',
+            parameters: {
+                type: 'object',
+                properties: { includeBuild: { type: 'boolean', description: 'Also run the build check; default false' } },
+                additionalProperties: false,
+            },
+            execute: async (args, context) => {
+                if (args.includeBuild !== undefined && typeof args.includeBuild !== 'boolean')
+                    throw new Error('includeBuild must be a boolean');
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const authorizer = createQaAuthorizer('qa.fast', context);
+                authorizer.assertPlanned(orchestrator.plannedCommands(await orchestrator.getProfile(context.signal)));
+                const report = await orchestrator.fast({ includeBuild: args.includeBuild === true, signal: context.signal, authorize: command => authorizer.authorize(command) });
+                return reportOutput(report);
+            },
+            eventOutput: reportEventOutput,
+        },
+        {
+            name: 'qa.test',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Run the project unit suite scoped by mode: "related" re-runs tests related to changed files, "file" runs the exact test files listed, "pattern" runs tests whose name matches a filter, and "all" runs the full suite. Prefer related/file while iterating on a specific failure.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    mode: { type: 'string', enum: ['related', 'file', 'pattern', 'all'], description: 'Test scoping mode' },
+                    files: { type: 'array', items: { type: 'string' }, description: 'Workspace-relative file paths; required for related and file modes' },
+                    pattern: { type: 'string', description: 'Test name filter; required for pattern mode' },
+                },
+                required: ['mode'],
+                additionalProperties: false,
+            },
+            execute: async (args, context) => {
+                const mode = args.mode;
+                const files = validateStringArray(args.files, 'files', 100);
+                const pattern = args.pattern;
+                if (typeof pattern === 'string' && (pattern.includes('\0') || pattern.length > 512))
+                    throw new Error('pattern must be under 512 characters without NUL bytes');
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const authorizer = createQaAuthorizer('qa.test', context);
+                authorizer.assertPlanned(orchestrator.plannedCommands(await orchestrator.getProfile(context.signal)));
+                const result = await orchestrator.test({ mode, files, pattern }, { signal: context.signal, authorize: command => authorizer.authorize(command) });
+                return JSON.stringify(compactResult(result));
+            },
+        },
+        {
+            name: 'qa.terminal',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Drive a persistent real PTY/ConPTY session for CLI and TUI smoke testing. Spawn the application once, then read terminal output, write text, send keys, wait for text/regex without polling sleeps, resize, inspect status, or kill it. Prefer short event-driven waits (5-15s) so hangs fail promptly instead of consuming shell timeouts.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', enum: ['spawn', 'read', 'write', 'key', 'wait', 'resize', 'status', 'kill'], description: 'Terminal operation to perform' },
+                    id: { type: 'string', description: 'Short terminal session id; required except status may omit it to list sessions' },
+                    command: { type: 'string', description: 'Command to launch inside the PTY; required for spawn' },
+                    data: { type: 'string', description: 'Raw text to write; required for write' },
+                    key: { type: 'string', description: 'Key name such as ENTER, UP, CTRL_C, or CTRL_T; required for key' },
+                    pattern: { type: 'string', description: 'Text or regex to await; required for wait' },
+                    regex: { type: 'boolean', description: 'Treat pattern as a regular expression; default false' },
+                    timeoutMs: { type: 'integer', minimum: 100, maximum: 60000, description: 'Event-driven wait timeout; default 5000ms' },
+                    cols: { type: 'integer', minimum: 20, maximum: 300, description: 'Terminal columns; spawn default 120' },
+                    rows: { type: 'integer', minimum: 5, maximum: 120, description: 'Terminal rows; spawn default 36' },
+                    fromCursor: { type: 'integer', minimum: 0, description: 'Read/wait only output at or after this terminal cursor' },
+                },
+                required: ['action'],
+                additionalProperties: false,
+            },
+            execute: async (args, context) => {
+                const action = args.action;
+                if (typeof action !== 'string' || !['spawn', 'read', 'write', 'key', 'wait', 'resize', 'status', 'kill'].includes(action)) {
+                    throw new Error('action must be spawn, read, write, key, wait, resize, status or kill');
+                }
+                const manager = getQaPtyManager(context.workspace);
+                const id = args.id;
+                if (action === 'status' && id === undefined)
+                    return JSON.stringify(manager.list());
+                if (typeof id !== 'string')
+                    throw new Error('id is required for this terminal action');
+                if (action === 'spawn') {
+                    if (typeof args.command !== 'string')
+                        throw new Error('command is required for spawn');
+                    assertTerminalApplication(args.command);
+                    const authorizer = createQaAuthorizer('qa.terminal', context);
+                    authorizer.assertPlanned([args.command]);
+                    await authorizer.authorize(args.command);
+                    return JSON.stringify(await manager.start({
+                        id,
+                        command: args.command,
+                        ...(typeof args.cols === 'number' ? { cols: args.cols } : {}),
+                        ...(typeof args.rows === 'number' ? { rows: args.rows } : {}),
+                        lifetimeSignal: context.userSignal ?? context.signal,
+                    }));
+                }
+                if (action === 'read') {
+                    return clipText(JSON.stringify(manager.read(id, typeof args.fromCursor === 'number' ? args.fromCursor : undefined)), 24_000);
+                }
+                if (action === 'write') {
+                    if (typeof args.data !== 'string')
+                        throw new Error('data is required for write');
+                    return JSON.stringify(manager.write(id, args.data));
+                }
+                if (action === 'key') {
+                    if (typeof args.key !== 'string')
+                        throw new Error('key is required for key');
+                    return JSON.stringify(manager.key(id, args.key));
+                }
+                if (action === 'wait') {
+                    if (typeof args.pattern !== 'string')
+                        throw new Error('pattern is required for wait');
+                    const result = await manager.waitFor({
+                        id,
+                        pattern: args.pattern,
+                        regex: args.regex === true,
+                        timeoutMs: typeof args.timeoutMs === 'number' ? args.timeoutMs : 5_000,
+                        ...(typeof args.fromCursor === 'number' ? { fromCursor: args.fromCursor } : {}),
+                        signal: context.signal,
+                    });
+                    return clipText(JSON.stringify(result), 24_000);
+                }
+                if (action === 'resize') {
+                    return JSON.stringify(manager.resize(id, typeof args.cols === 'number' ? args.cols : undefined, typeof args.rows === 'number' ? args.rows : undefined));
+                }
+                if (action === 'status')
+                    return JSON.stringify(manager.get(id));
+                await manager.stop(id);
+                return JSON.stringify({ id, stopped: true });
+            },
+            eventOutput: output => {
+                try {
+                    const parsed = JSON.parse(output);
+                    if (Array.isArray(parsed))
+                        return JSON.stringify(parsed);
+                    const { output: _terminalOutput, ...metadata } = parsed;
+                    return JSON.stringify(metadata);
+                }
+                catch {
+                    return output.slice(0, 500);
+                }
+            },
+        },
+        {
+            name: 'qa.browser',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Load a URL in headless Playwright Chromium and report page load failures, console/page errors, failed or 4xx/5xx network requests, and axe accessibility violations when enabled. The app under test must already be running; the URL comes from the argument, browser.url, or qa.startup.health_url. Results are BLOCKED when Playwright is unavailable rather than silently skipped.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to load; defaults to the configured browser url' },
+                    accessibility: { type: 'boolean', description: 'Run axe-core accessibility checks; requires axe-core installed' },
+                },
+                additionalProperties: false,
+            },
+            execute: async (args, context) => {
+                const url = args.url;
+                if (url !== undefined && !/^https?:\/\//i.test(url))
+                    throw new Error('url must be an http(s) URL');
+                if (args.accessibility !== undefined && typeof args.accessibility !== 'boolean')
+                    throw new Error('accessibility must be a boolean');
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const results = await orchestrator.browser({ ...(url ? { url } : {}), ...(typeof args.accessibility === 'boolean' ? { accessibility: args.accessibility } : {}), signal: context.signal });
+                return clipText(JSON.stringify({ results: results.map(compactResult), summary: results.map(result => `${result.id}: ${result.status.toUpperCase()} — ${result.summary}`).join('\n') }), 24_000);
+            },
+        },
+        {
+            name: 'qa.security',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Run security checks over the working tree: the built-in secret scan over all added lines (matched values are redacted), a dependency audit (npm/pnpm/yarn) against the configured severity cascade, and semgrep when enabled in .andorra/qa.yaml. Always run this before considering a merge; secret findings block the merge gate.',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+            execute: async (_args, context) => {
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const authorizer = createQaAuthorizer('qa.security', context);
+                authorizer.assertPlanned(orchestrator.plannedCommands(await orchestrator.getProfile(context.signal)));
+                const results = await orchestrator.security({ signal: context.signal, authorize: command => authorizer.authorize(command) });
+                return clipText(JSON.stringify({ results: results.map(compactResult), summary: results.map(result => `${result.id}: ${result.status.toUpperCase()} — ${result.summary}`).join('\n') }), 24_000);
+            },
+        },
+        {
+            name: 'qa.deep',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Run the full merge gate for the current change set: the configured base gate (lint, typecheck, related tests, build, diff review, secret scan) plus checks the change classification adds — browser checks for frontend changes, runtime smoke when a startup command exists, API smoke, dependency audit, semgrep. Optional checks narrows to a subset of gate step ids. A ready verdict means every required check passed or was legitimately skipped.',
+            parameters: {
+                type: 'object',
+                properties: { checks: { type: 'array', items: { type: 'string' }, description: 'Optional subset of gate step ids to run' } },
+                additionalProperties: false,
+            },
+            execute: async (args, context) => {
+                const checks = validateStringArray(args.checks, 'checks', 32);
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const authorizer = createQaAuthorizer('qa.deep', context);
+                authorizer.assertPlanned(orchestrator.plannedCommands(await orchestrator.getProfile(context.signal)));
+                const report = await orchestrator.deep({ signal: context.signal, authorize: command => authorizer.authorize(command), ...(checks ? { checks } : {}) });
+                return reportOutput(report);
+            },
+            eventOutput: reportEventOutput,
+        },
+        {
+            name: 'qa.status',
+            family: 'qa',
+            executionMode: 'sequential',
+            description: 'Show the QA session view: derived profile summary, every recorded check result this session, whether results are stale because the working tree changed since they were recorded, consecutive failure counts per check, and the last merge-gate verdict. Runs host Git and runtime probes; restricted permissions require scoped approval.',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+            execute: async (_args, context) => {
+                const orchestrator = getQaOrchestrator(context.workspace);
+                const { summary, state } = await orchestrator.status(context.signal);
+                const checks = Object.values(state.checks);
+                const lines = checks.map(result => `${result.id}: ${result.status.toUpperCase()} — ${result.summary}${result.repairExhausted ? ' (repair attempts exhausted)' : ''}${orchestrator.isStale(result.fingerprint ?? '') ? ' [STALE: working tree changed since this result]' : ''}`);
+                return `${summary}\n\nQA results:\n${lines.join('\n') || 'none yet'}\nchangedSinceLastQa: ${state.changedSinceLastQa}\nmergeReady: ${state.mergeReady}${state.lastGateVerdict ? ` (last verdict ${state.lastGateVerdict})` : ''}`;
+            },
+        },
+    ];
+}

package/dist/src/qa/types.d.ts

@@ -0,0 +1,134 @@
+/** Normalized QA result vocabulary shared by every runner and the LLM-facing tools. */
+export type QaCheckCategory = 'lint' | 'typecheck' | 'unit' | 'build' | 'e2e' | 'security' | 'accessibility' | 'visual' | 'runtime' | 'diff';
+/** passed/failed describe executed checks; blocked means the check could not run; skipped means it does not apply. */
+export type QaCheckStatus = 'passed' | 'failed' | 'skipped' | 'blocked';
+export type QaSeverity = 'error' | 'warning' | 'info';
+export interface QaIssue {
+    file?: string;
+    line?: number;
+    column?: number;
+    severity: QaSeverity;
+    message: string;
+    code?: string;
+}
+export interface QaCheckResult {
+    id: string;
+    category: QaCheckCategory;
+    status: QaCheckStatus;
+    durationMs: number;
+    summary: string;
+    errors?: QaIssue[];
+    /** Workspace-relative raw log path under .andorra/runtime/qa/<run>/, present when a command ran. */
+    logRef?: string;
+    /** Git working-tree fingerprint captured when the result was recorded; drives staleness detection. */
+    fingerprint?: string;
+    /** Bounded error lines handed to the model so full logs stay out of context. */
+    importantOutput?: string[];
+    /** True when the configured auto-repair budget is exhausted for this check. */
+    repairExhausted?: boolean;
+}
+export interface ShellExecuteResult {
+    command: string;
+    cwd: string;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    truncated: boolean;
+    exitSignal?: NodeJS.Signals | null;
+}
+export interface ShellEnvironment {
+    platform: 'windows' | 'macos' | 'linux';
+    executable: string;
+    argsPrefix: string[];
+}
+export interface RuntimeToolCapability {
+    available: boolean;
+    version?: string;
+}
+export interface RuntimeCapabilities {
+    shell: ShellEnvironment;
+    tools: Record<string, RuntimeToolCapability>;
+}
+export interface QaCommandSpec {
+    command: string;
+    timeoutMs?: number;
+}
+export interface QaStartupSpec {
+    command: string;
+    healthUrl?: string;
+    timeoutMs?: number;
+}
+export interface QaApiSmokeTest {
+    name: string;
+    request: {
+        method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+        url: string;
+        headers?: Record<string, string>;
+        body?: string;
+    };
+    expect?: {
+        status?: number;
+        bodyContains?: string;
+        timeoutMs?: number;
+    };
+}
+/** Repository QA profile: derived by inspection, overlaid by .andorra/qa.yaml when present. */
+export interface QaProfile {
+    project: {
+        language: string;
+        framework?: string;
+        packageManager?: string;
+        /** Marker files that influenced detection; used for cache invalidation. */
+        detectedFiles: string[];
+    };
+    qa: Partial<Record<'lint' | 'typecheck' | 'unit' | 'build' | 'e2e', QaCommandSpec>>;
+    test?: {
+        runner?: 'jest' | 'vitest' | 'node' | 'pytest' | 'other';
+        /** Command template with a {files} or {pattern} placeholder; overrides derived scoping. */
+        relatedCommand?: string;
+        patternCommand?: string;
+    };
+    startup?: QaStartupSpec;
+    security: {
+        dependencyScan: boolean;
+        secretScan: boolean;
+        semgrep: boolean;
+        failOn: QaSeverityCascade[];
+    };
+    browser: {
+        framework?: string;
+        enabled: boolean;
+        url?: string;
+        ignoredConsolePatterns: string[];
+        allowedHttpErrors: {
+            path: string;
+            status: number;
+        }[];
+        accessibility: boolean;
+    };
+    mergeGate: string[];
+    autoRepair: {
+        enabled: boolean;
+        maxAttemptsPerCheck: number;
+    };
+    apiSmokeTests: QaApiSmokeTest[];
+    /** Workspace-relative paths of the configuration/markers files that shaped this profile. */
+    sources: string[];
+    /** Set when .andorra/qa.yaml exists but failed validation; derived defaults still apply. */
+    configError?: string;
+}
+/** Severity cascade entries; ordered weakest to strongest by convention. */
+export type QaSeverityCascade = 'critical' | 'high' | 'moderate' | 'low' | 'info' | 'warning' | 'error';
+export interface QaSessionState {
+    lastFastRun?: string;
+    lastDeepRun?: string;
+    checks: Record<string, QaCheckResult>;
+    changedSinceLastQa: boolean;
+    mergeReady: boolean;
+    lastGateVerdict?: 'ready' | 'failed' | 'blocked';
+    /** Consecutive failures per check since its last pass; bounds the repair loop. */
+    failureCounts: Record<string, number>;
+}
+export declare function emptyQaState(): QaSessionState;

package/dist/src/qa/types.js

@@ -0,0 +1,3 @@
+export function emptyQaState() {
+    return { checks: {}, changedSinceLastQa: false, mergeReady: false, failureCounts: {} };
+}

package/dist/src/react-runtime.d.ts

@@ -0,0 +1,53 @@
+import { TodoStore } from './todos.js';
+import type { Message, Tool, ToolCall } from './types.js';
+import { type RunOptions, type RunResult } from './runtime.js';
+export type ToolExecutionMode = 'parallel' | 'sequential';
+export interface BeforeToolCallContext {
+    toolCall: ToolCall;
+    tool: Tool;
+    args: Record<string, unknown>;
+}
+export interface BeforeToolCallResult {
+    block?: boolean;
+    reason?: string;
+}
+export interface AfterToolCallContext extends BeforeToolCallContext {
+    output: string;
+    isError: boolean;
+}
+export interface AfterToolCallResult {
+    output?: string;
+    isError?: boolean;
+}
+/**
+ * Andorra integration hooks for the shared, adapted upstream engine.
+ * The graph runtime still owns routing, budgets, capabilities, approvals and artifacts.
+ */
+export interface HardenedRunOptions extends RunOptions {
+    toolExecution?: ToolExecutionMode;
+    /** Active-goal verification is opt-in, as in upstream; ordinary prose has no hidden verifier request. */
+    verifyCompletion?: (input: {
+        text: string;
+        messages: Message[];
+        pendingTodos: ReturnType<TodoStore['snapshot']>;
+    }, signal: AbortSignal) => Promise<{
+        passed: boolean;
+        reason: string;
+    }>;
+    transformContext?: (messages: Message[], signal: AbortSignal) => Promise<Message[]>;
+    getSteeringMessages?: (signal: AbortSignal) => Promise<Message[]>;
+    getFollowUpMessages?: (signal: AbortSignal) => Promise<Message[]>;
+    beforeToolCall?: (context: BeforeToolCallContext, signal: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
+    afterToolCall?: (context: AfterToolCallContext, signal: AbortSignal) => Promise<AfterToolCallResult | undefined>;
+}
+/**
+ * One engine for all reasoning nodes. The copied agent owns turn scheduling, tool
+ * batches and session state; these hooks enforce Andorra's graph contracts.
+ */
+export declare class AndorraAgentEngine {
+    execute(options: HardenedRunOptions): Promise<RunResult>;
+}
+/** Compatibility import for saved callers; no alternate loop exists. */
+export { AndorraAgentEngine as HardenedReActAgentExecutor };
+/** Shared factory used by graph roles, delegated copies and standalone calls. */
+export declare function createAgentEngine(): AndorraAgentEngine;