@webpresso/agent-kit 0.21.0

package/dist/esm/audit/agents.js

@@ -0,0 +1,331 @@
+import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { readConfig } from '#cli/commands/init/config';
+const REQUIRED_HOOKS = [
+    { event: 'SessionStart', bin: 'wp-sessionstart-routing' },
+    { event: 'PreToolUse', bin: 'wp-pretool-guard' },
+    { event: 'PostToolUse', bin: 'wp-post-tool' },
+    { event: 'UserPromptSubmit', bin: 'wp-guard-switch' },
+    { event: 'Stop', bin: 'wp-stop-qa' },
+];
+const CLAUDE_SETTINGS_PATH = '.claude/settings.json';
+const CODEX_HOOKS_PATH = '.codex/hooks.json';
+const REQUIRED_SUBAGENTS = [
+    'code-reviewer.md',
+    'security-auditor.md',
+    'doc-writer.md',
+    'explorer.md',
+];
+export function auditAgents(rootDirectory = process.cwd()) {
+    const root = resolve(rootDirectory);
+    const violations = [];
+    let checked = 0;
+    const packageJson = readJsonFile(join(root, 'package.json'));
+    const packageName = typeof packageJson.name === 'string' ? packageJson.name : undefined;
+    const isSelfHost = packageName === 'webpresso' || packageName === '@webpresso/agent-kit';
+    const config = readConfig(root);
+    checked += 1;
+    checkNonEmptyFile(root, 'AGENTS.md', violations, 'AGENTS.md is required at repo root and must be non-empty.');
+    if (isSelfHost) {
+        // Agent surfaces (.agent/.claude/.codex/etc.) are generated and gitignored
+        // in the source repo. For self-host, audit the canonical catalog sources
+        // instead of requiring generated projections to exist in a clean checkout.
+        checked += 1;
+        checkCatalogRules(root, violations);
+        checked += 1;
+        checkCatalogAgents(root, violations);
+    }
+    else {
+        checked += 1;
+        checkHookFile(root, CLAUDE_SETTINGS_PATH, 'claude', violations);
+        checked += 1;
+        checkClaudeWorktree(root, violations);
+        checked += 1;
+        checkHookFile(root, CODEX_HOOKS_PATH, 'codex', violations);
+        checked += 1;
+        checkClaudeRules(root, config?.rules.overrides ?? [], violations);
+        checked += 1;
+        checkClaudeAgents(root, violations);
+        checked += 1;
+        checkSetupAgentScript(root, packageJson, config?.scripts['setup-agent'], violations);
+        if (!config?.globalInstall) {
+            checked += 1;
+            checkAgentKitDevDependency(root, packageJson, violations);
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        title: 'Agent surfaces',
+        checked,
+        violations,
+    };
+}
+function checkCatalogRules(root, violations) {
+    const rulesSource = join(root, 'catalog', 'agent', 'rules');
+    if (!existsSync(rulesSource)) {
+        violations.push({
+            file: 'catalog/agent/rules',
+            message: 'Missing catalog/agent/rules source directory.',
+        });
+        return;
+    }
+    const sourceEntries = readdirSync(rulesSource).filter((file) => file.endsWith('.md') && file !== 'README.md' && file !== '.markdownlint.json');
+    if (sourceEntries.length === 0) {
+        violations.push({
+            file: 'catalog/agent/rules',
+            message: 'catalog/agent/rules must contain canonical rule markdown files.',
+        });
+    }
+}
+function checkCatalogAgents(root, violations) {
+    const agentsSource = join(root, 'catalog', 'agent', 'agents');
+    if (!existsSync(agentsSource)) {
+        violations.push({
+            file: 'catalog/agent/agents',
+            message: 'Missing catalog/agent/agents source directory.',
+        });
+        return;
+    }
+    for (const file of REQUIRED_SUBAGENTS) {
+        const sourcePath = join(agentsSource, file);
+        if (!existsSync(sourcePath)) {
+            violations.push({
+                file: relative(root, sourcePath),
+                message: `Missing canonical subagent ${file} in catalog/agent/agents.`,
+            });
+        }
+    }
+}
+function checkClaudeAgents(root, violations) {
+    const agentsTarget = join(root, '.claude', 'agents');
+    if (!existsSync(agentsTarget)) {
+        violations.push({
+            file: '.claude/agents',
+            message: 'Missing .claude/agents directory — run `wp setup` to scaffold canonical subagents.',
+        });
+        return;
+    }
+    for (const file of REQUIRED_SUBAGENTS) {
+        const targetPath = join(agentsTarget, file);
+        if (!existsSync(targetPath)) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Missing Claude subagent ${file}. Run \`wp setup\` to re-sync canonical subagents.`,
+            });
+            continue;
+        }
+        const stat = lstatSync(targetPath);
+        if (!stat.isSymbolicLink()) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Canonical subagent ${file} must remain a symlink to catalog/agent/agents/${file}.`,
+            });
+            continue;
+        }
+        const linkTarget = readlinkSync(targetPath).replace(/\\/gu, '/');
+        const resolvedTarget = resolve(dirname(targetPath), linkTarget);
+        const expectedSuffix = `/catalog/agent/agents/${file}`;
+        const looksLikeCanonicalTarget = linkTarget.endsWith(expectedSuffix) || basename(resolvedTarget) === file;
+        if (!looksLikeCanonicalTarget) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Canonical subagent ${file} points to ${JSON.stringify(linkTarget)} instead of a recognized catalog target.`,
+            });
+            continue;
+        }
+        if (!existsSync(resolvedTarget)) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Canonical subagent ${file} symlink is dangling. Run \`wp setup\` to repair it.`,
+            });
+        }
+    }
+}
+function checkNonEmptyFile(root, relativePath, violations, message) {
+    const filePath = join(root, relativePath);
+    if (!existsSync(filePath)) {
+        violations.push({ file: relativePath, message });
+        return;
+    }
+    const content = readFileSync(filePath, 'utf8').trim();
+    if (content.length === 0) {
+        violations.push({ file: relativePath, message });
+    }
+}
+function checkHookFile(root, relativePath, host, violations) {
+    const filePath = join(root, relativePath);
+    if (!existsSync(filePath)) {
+        violations.push({
+            file: relativePath,
+            message: host === 'claude'
+                ? 'Missing .claude/settings.json — run `wp setup` to scaffold Claude hooks.'
+                : 'Missing .codex/hooks.json — run `wp setup` to scaffold Codex hooks.',
+        });
+        return;
+    }
+    const hooks = parseHooks(readFileSync(filePath, 'utf8'), host);
+    for (const requirement of REQUIRED_HOOKS) {
+        const groups = hooks[requirement.event] ?? [];
+        const found = groups.some((group) => (group.hooks ?? []).some((hook) => hook.command?.includes(requirement.bin)));
+        if (!found) {
+            violations.push({
+                file: relativePath,
+                message: `Missing ${requirement.event} hook for ${requirement.bin}. Re-run \`wp setup\` to repair agent hooks.`,
+            });
+        }
+    }
+}
+function checkClaudeWorktree(root, violations) {
+    const settingsPath = join(root, CLAUDE_SETTINGS_PATH);
+    if (!existsSync(settingsPath))
+        return;
+    const parsed = readJsonFile(settingsPath);
+    const worktree = parsed.worktree;
+    const symlinkDirectories = Array.isArray(worktree?.symlinkDirectories)
+        ? worktree?.symlinkDirectories
+        : [];
+    if (!symlinkDirectories.includes('.claude')) {
+        violations.push({
+            file: CLAUDE_SETTINGS_PATH,
+            message: 'worktree.symlinkDirectories must include `.claude` so worktrees inherit agent surfaces.',
+        });
+    }
+}
+function checkClaudeRules(root, overrides, violations) {
+    const rulesSource = join(root, '.agent', 'rules');
+    const rulesTarget = join(root, '.claude', 'rules');
+    const overrideSet = new Set(overrides);
+    if (!existsSync(rulesSource)) {
+        violations.push({
+            file: '.agent/rules',
+            message: 'Missing .agent/rules source directory.',
+        });
+        return;
+    }
+    if (!existsSync(rulesTarget)) {
+        violations.push({
+            file: '.claude/rules',
+            message: 'Missing .claude/rules directory — run `wp setup` to scaffold rule symlinks.',
+        });
+        return;
+    }
+    const sourceEntries = readdirSync(rulesSource).filter((file) => file.endsWith('.md') && file !== 'README.md' && file !== '.markdownlint.json');
+    const targetEntries = new Set(readdirSync(rulesTarget).filter((file) => file.endsWith('.md')));
+    for (const file of sourceEntries) {
+        const ruleName = file.replace(/\.md$/u, '');
+        const targetPath = join(rulesTarget, file);
+        const isOverride = overrideSet.has(ruleName);
+        if (!existsSync(targetPath)) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: isOverride
+                    ? `Allowlisted override ${ruleName} is missing its .claude/rules entry.`
+                    : `Missing Claude rule link for ${ruleName}. Run \`wp setup\` to re-sync.`,
+            });
+            continue;
+        }
+        const stat = lstatSync(targetPath);
+        if (isOverride) {
+            if (stat.isSymbolicLink()) {
+                violations.push({
+                    file: relative(root, targetPath),
+                    message: `Rule ${ruleName} is allowlisted as an override but is still a symlink. Replace it with consumer-owned content or remove the override.`,
+                });
+            }
+            continue;
+        }
+        if (!stat.isSymbolicLink()) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Rule ${ruleName} is a real file but not allowlisted in .webpressorc.json#rules.overrides.`,
+            });
+            continue;
+        }
+        const linkTarget = readlinkSync(targetPath).replace(/\\/gu, '/');
+        const resolvedTarget = resolve(dirname(targetPath), linkTarget);
+        const expectedLegacy = join('..', '..', '.agent', 'rules', file).replace(/\\/gu, '/');
+        const looksLikeDirectRuleTarget = linkTarget.endsWith(`/catalog/agent/rules/${file}`) ||
+            linkTarget.endsWith(`/.agent/rules/${file}`) ||
+            basename(resolvedTarget) === file;
+        if (linkTarget !== expectedLegacy && !looksLikeDirectRuleTarget) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Rule ${ruleName} points to ${JSON.stringify(linkTarget)} instead of a recognized rule target.`,
+            });
+            continue;
+        }
+        if (!existsSync(resolvedTarget)) {
+            violations.push({
+                file: relative(root, targetPath),
+                message: `Rule ${ruleName} symlink is dangling. Run \`wp setup\` to repair it.`,
+            });
+        }
+    }
+    for (const file of targetEntries) {
+        const ruleName = file.replace(/\.md$/u, '');
+        if (sourceEntries.includes(file))
+            continue;
+        if (overrideSet.has(ruleName))
+            continue;
+        violations.push({
+            file: relative(root, join(rulesTarget, file)),
+            message: `Unexpected Claude rule ${file}. Remove it or add ${ruleName} to .webpressorc.json#rules.overrides.`,
+        });
+    }
+}
+function checkSetupAgentScript(root, packageJson, overrideCommand, violations) {
+    const scripts = (packageJson.scripts ?? {});
+    const actual = typeof scripts['setup:agent'] === 'string' ? scripts['setup:agent'] : undefined;
+    const expected = overrideCommand ?? 'wp setup';
+    if (actual !== expected) {
+        violations.push({
+            file: 'package.json',
+            message: actual === undefined
+                ? `Missing scripts.setup:agent. Expected ${JSON.stringify(expected)}.`
+                : `scripts.setup:agent must be ${JSON.stringify(expected)} (got ${JSON.stringify(actual)}).`,
+        });
+    }
+}
+function checkAgentKitDevDependency(root, packageJson, violations) {
+    const devDependencies = (packageJson.devDependencies ?? {});
+    const packageName = typeof packageJson.name === 'string' ? packageJson.name : '';
+    const version = devDependencies['webpresso'] ?? devDependencies['@webpresso/agent-kit'];
+    const scripts = (packageJson.scripts ?? {});
+    const setupAgent = typeof scripts['setup:agent'] === 'string' ? scripts['setup:agent'] : '';
+    const postinstall = typeof scripts.postinstall === 'string' ? scripts.postinstall : '';
+    const usesGlobalWpConsumerMode = setupAgent === 'wp setup' && postinstall.includes('wp-restore-dev-links');
+    if (packageName === '@webpresso/agent-kit') {
+        return;
+    }
+    if (usesGlobalWpConsumerMode) {
+        return;
+    }
+    if (typeof version !== 'string' || version.trim().length === 0) {
+        violations.push({
+            file: 'package.json',
+            message: 'Missing devDependency `webpresso` or `@webpresso/agent-kit`. Run `vp install -D <package>` then `vp install`.',
+        });
+    }
+}
+function parseHooks(raw, host) {
+    const parsed = readJsonContent(raw);
+    if (!parsed || typeof parsed !== 'object')
+        return {};
+    // Both Claude and Codex use the wrapped form `{ "hooks": { Event: [...] } }`
+    // per their canonical docs (https://developers.openai.com/codex/hooks).
+    // The agent-hooks scaffolder writes wrapped via `hoistTopLevelEvents`; the
+    // audit must read it the same way or it will report false negatives.
+    // For Codex, fall back to the parsed root if `hooks` is absent so legacy
+    // pre-migration flat-form files still audit cleanly.
+    const hooks = parsed.hooks;
+    if (hooks && typeof hooks === 'object')
+        return hooks;
+    return host === 'codex' ? parsed : {};
+}
+function readJsonFile(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function readJsonContent(source) {
+    return JSON.parse(source);
+}
+//# sourceMappingURL=agents.js.map

package/dist/esm/audit/ai-contracts.d.ts

@@ -0,0 +1,3 @@
+import type { RepoAuditResult } from './repo-guardrails.js';
+export declare function auditAiContracts(rootDirectory?: string): RepoAuditResult;
+//# sourceMappingURL=ai-contracts.d.ts.map

package/dist/esm/audit/ai-contracts.js

@@ -0,0 +1,238 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import ts from 'typescript';
+const CONTRACT_DOC_PATH = 'docs/ai-reliability-contract.md';
+const RESULT_HELPER_PATH = 'src/mcp/tools/_shared/result.ts';
+const MCP_DISCOVERY_PATH = 'src/mcp/auto-discover.ts';
+const MCP_INTEGRATION_TEST_PATH = 'src/mcp/server.integration.test.ts';
+const SUMMARY_FIRST_TOOLS = [
+    'src/mcp/tools/test.ts',
+    'src/mcp/tools/lint.ts',
+    'src/mcp/tools/typecheck.ts',
+    'src/mcp/tools/qa.ts',
+    'src/mcp/tools/audit.ts',
+];
+const EXPLICIT_ERROR_TOOLS = [
+    'src/mcp/tools/lint.ts',
+    'src/mcp/tools/qa.ts',
+    'src/mcp/tools/audit.ts',
+    'src/mcp/tools/format.ts',
+    'src/mcp/tools/ci-act.ts',
+];
+export function auditAiContracts(rootDirectory = process.cwd()) {
+    const root = resolve(rootDirectory);
+    const violations = [];
+    let checked = 0;
+    checked += expectFileContains(root, CONTRACT_DOC_PATH, '# AI Reliability Contract', violations, {
+        message: 'Missing canonical AI reliability contract doc. Add docs/ai-reliability-contract.md so consumers have one source of truth.',
+    });
+    checked += expectFileContains(root, CONTRACT_DOC_PATH, '## Contract Rules', violations, {
+        message: 'AI reliability doc must define contract rules explicitly.',
+    });
+    checked += expectSourcePredicate(root, RESULT_HELPER_PATH, hasCreateSummaryResultStructuredPayload, violations, {
+        message: 'Summary-first MCP result helper must return structuredContent and support explicit isError signaling.',
+    });
+    checked += expectSourcePredicate(root, MCP_DISCOVERY_PATH, (sourceFile) => hasInterfaceProperty(sourceFile, 'ToolHandlerResult', 'structuredContent') &&
+        hasInterfaceProperty(sourceFile, 'ToolHandlerResult', 'isError') &&
+        hasInterfaceProperty(sourceFile, 'ToolDescriptor', 'outputSchema'), violations, {
+        message: 'Tool discovery contract must advertise structuredContent, isError, and outputSchema.',
+    });
+    checked += expectFileContains(root, MCP_INTEGRATION_TEST_PATH, 'tools/list', violations, {
+        message: 'MCP integration tests must exercise tools/list to verify advertised schemas.',
+    });
+    checked += expectFileContains(root, MCP_INTEGRATION_TEST_PATH, 'structuredContent', violations, {
+        message: 'MCP integration tests must assert structuredContent passthrough for built-in tools.',
+    });
+    for (const toolPath of SUMMARY_FIRST_TOOLS) {
+        checked += expectSourcePredicate(root, toolPath, (sourceFile) => defaultExportObjectHasProperty(sourceFile, 'outputSchema') &&
+            fileCallsIdentifier(sourceFile, 'createSummaryResult'), violations, {
+            message: 'Summary-first wp_* tools must advertise outputSchema and return results via createSummaryResult().',
+        });
+    }
+    for (const toolPath of EXPLICIT_ERROR_TOOLS) {
+        checked += expectSourcePredicate(root, toolPath, hasIsErrorTrueObjectLiteral, violations, {
+            message: 'Tools with composition/spawn/parse failure branches should mark tool execution failure with isError: true.',
+        });
+    }
+    return {
+        ok: violations.length === 0,
+        title: 'AI contracts audit',
+        checked,
+        violations,
+    };
+}
+function expectFileContains(root, relativePath, needle, violations, options) {
+    const filePath = resolve(root, relativePath);
+    if (!existsSync(filePath)) {
+        violations.push({
+            file: relativePath,
+            message: `${options.message} File is missing.`,
+        });
+        return 1;
+    }
+    const content = readFileSync(filePath, 'utf8');
+    if (!content.includes(needle)) {
+        violations.push({
+            file: relativePath,
+            message: `${options.message} Expected to find ${JSON.stringify(needle)}.`,
+        });
+    }
+    return 1;
+}
+function expectSourcePredicate(root, relativePath, predicate, violations, options) {
+    const sourceFile = loadSourceFile(root, relativePath);
+    if (!sourceFile) {
+        violations.push({
+            file: relativePath,
+            message: `${options.message} File is missing or unreadable.`,
+        });
+        return 1;
+    }
+    if (!predicate(sourceFile)) {
+        violations.push({
+            file: relativePath,
+            message: options.message,
+        });
+    }
+    return 1;
+}
+function loadSourceFile(root, relativePath) {
+    const filePath = resolve(root, relativePath);
+    if (!existsSync(filePath))
+        return undefined;
+    const content = readFileSync(filePath, 'utf8');
+    return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function hasInterfaceProperty(sourceFile, interfaceName, propertyName) {
+    let found = false;
+    visit(sourceFile, (node) => {
+        if (ts.isInterfaceDeclaration(node) &&
+            node.name.text === interfaceName &&
+            node.members.some((member) => ts.isPropertySignature(member) && getPropertyName(member.name) === propertyName)) {
+            found = true;
+            return true;
+        }
+        return false;
+    });
+    return found;
+}
+function hasCreateSummaryResultStructuredPayload(sourceFile) {
+    let foundStructuredContent = false;
+    let foundIsError = false;
+    visit(sourceFile, (node) => {
+        if (!ts.isFunctionDeclaration(node) || node.name?.text !== 'createSummaryResult') {
+            return false;
+        }
+        visit(node.body, (inner) => {
+            if (!ts.isObjectLiteralExpression(inner))
+                return false;
+            for (const property of inner.properties) {
+                if (ts.isPropertyAssignment(property)) {
+                    const name = getPropertyName(property.name);
+                    if (name === 'structuredContent')
+                        foundStructuredContent = true;
+                    if (name === 'isError' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                        foundIsError = true;
+                    }
+                }
+                if (ts.isSpreadAssignment(property) &&
+                    ts.isConditionalExpression(property.expression) &&
+                    ts.isObjectLiteralExpression(property.expression.whenTrue)) {
+                    for (const spreadProperty of property.expression.whenTrue.properties) {
+                        if (ts.isPropertyAssignment(spreadProperty) &&
+                            getPropertyName(spreadProperty.name) === 'isError' &&
+                            spreadProperty.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            foundIsError = true;
+                        }
+                    }
+                }
+            }
+            return false;
+        });
+        return true;
+    });
+    return foundStructuredContent && foundIsError;
+}
+function defaultExportObjectHasProperty(sourceFile, propertyName) {
+    let found = false;
+    visit(sourceFile, (node) => {
+        if (ts.isExportAssignment(node) && ts.isIdentifier(node.expression)) {
+            const identifier = node.expression.text;
+            const declaration = findVariableDeclaration(sourceFile, identifier);
+            if (declaration &&
+                declaration.initializer &&
+                ts.isObjectLiteralExpression(declaration.initializer) &&
+                declaration.initializer.properties.some((property) => (ts.isPropertyAssignment(property) &&
+                    getPropertyName(property.name) === propertyName) ||
+                    (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName))) {
+                found = true;
+                return true;
+            }
+        }
+        return false;
+    });
+    return found;
+}
+function findVariableDeclaration(sourceFile, identifier) {
+    let found;
+    visit(sourceFile, (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === identifier) {
+            found = node;
+            return true;
+        }
+        return false;
+    });
+    return found;
+}
+function fileCallsIdentifier(sourceFile, identifier) {
+    let found = false;
+    visit(sourceFile, (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === identifier) {
+            found = true;
+            return true;
+        }
+        return false;
+    });
+    return found;
+}
+function hasIsErrorTrueObjectLiteral(sourceFile) {
+    let found = false;
+    visit(sourceFile, (node) => {
+        if (!ts.isObjectLiteralExpression(node))
+            return false;
+        if (node.properties.some((property) => ts.isPropertyAssignment(property) &&
+            getPropertyName(property.name) === 'isError' &&
+            property.initializer.kind === ts.SyntaxKind.TrueKeyword)) {
+            found = true;
+            return true;
+        }
+        return false;
+    });
+    return found;
+}
+function getPropertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function visit(node, visitor) {
+    if (!node)
+        return;
+    let shouldStop = false;
+    const walk = (current) => {
+        if (shouldStop)
+            return;
+        if (visitor(current)) {
+            shouldStop = true;
+            return;
+        }
+        current.forEachChild(walk);
+    };
+    walk(node);
+}
+//# sourceMappingURL=ai-contracts.js.map

package/dist/esm/audit/architecture-drift.d.ts

@@ -0,0 +1,33 @@
+import type { RepoAuditResult } from './repo-guardrails.js';
+export interface ArchitectureDriftRule {
+    id: string;
+    description?: string;
+    paths: readonly string[];
+    mustContain?: readonly string[];
+    mustNotContain?: readonly string[];
+    allowMissing?: boolean;
+    caseSensitive?: boolean;
+}
+export interface ArchitectureBlueprintPolicy {
+    enabled?: boolean;
+    blueprintGlobs?: readonly string[];
+    architectureDocGlobs?: readonly string[];
+    requireArchitectureLinks?: boolean;
+    requireBeforeAfterWhenArchitectureChanging?: boolean;
+    architectureChangeMarkers?: readonly string[];
+    beforeHeading?: string;
+    afterHeading?: string;
+    exemptStatuses?: readonly string[];
+}
+export interface ArchitectureDriftContract {
+    version: 1;
+    architectureDocs?: readonly string[];
+    requiredFiles?: readonly string[];
+    rules?: readonly ArchitectureDriftRule[];
+    blueprintPolicy?: ArchitectureBlueprintPolicy;
+}
+export interface ArchitectureDriftOptions {
+    contractPath?: string;
+}
+export declare function auditArchitectureDrift(rootDirectory?: string, options?: ArchitectureDriftOptions): RepoAuditResult;
+//# sourceMappingURL=architecture-drift.d.ts.map