@webpresso/agent-kit 0.21.0

package/dist/esm/hooks/shared/validators/blueprint.js

@@ -0,0 +1,98 @@
+const SKIP_PATTERNS = [
+    /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$/,
+    /\.(test|spec)$/,
+    /\.e2e\.(ts|tsx|js)$/,
+    /\.e2e$/,
+    /\.(config|rc)\.(ts|js|mjs|cjs|json|yaml|yml)$/,
+    /(^|\/)\.[^/]+rc$/,
+    /(^|\/)[^/]+\.(config|rc)$/,
+    /\.(json|yaml|yml)$/,
+    /\.md$/,
+    /\.d\.ts$/,
+    /(^|\/)(__tests__|__mocks__|test\/|tests\/|e2e\/)/,
+    /(^|\/)node_modules\//,
+    /(^|\/)dist\//,
+    /(^|\/)build\//,
+    /(^|\/)\.(next|wrangler|cache)\//,
+    /(^|\/)coverage\//,
+    /(^|\/)\.claude\//,
+    /(^|\/)\.git\//,
+    /\.gitignore$/,
+    /(^|\/)infra\//,
+    /\.env/,
+    /(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb)$/,
+];
+export function shouldSkipFile(filePath) {
+    if (!filePath)
+        return false;
+    const normalized = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+    return SKIP_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+export function getSkipReason(filePath) {
+    const skipChecks = [
+        { pattern: /\.(test|spec)(\.|$)/, reason: 'test file' },
+        { pattern: /\.e2e(\.|$)/, reason: 'e2e test file' },
+        { pattern: /\.md$/, reason: 'documentation' },
+        { pattern: /\.(config|rc)(\.|$)/, reason: 'config file' },
+        { pattern: /\.(json|yaml|yml)$/, reason: 'data file' },
+        { pattern: /\.d\.ts$/, reason: 'type definitions' },
+        { pattern: /node_modules/, reason: 'node_modules' },
+        { pattern: /\.claude\//, reason: 'Claude config' },
+        { pattern: /infra\//, reason: 'infrastructure' },
+    ];
+    for (const { pattern, reason } of skipChecks) {
+        if (pattern.test(filePath))
+            return reason;
+    }
+    return 'excluded file';
+}
+export function validateBlueprint(filePath, options) {
+    const bypassEnabled = options?.bypassEnabled ??
+        (process.env.BLUEPRINT_GUARD_SKIP === '1' || process.env.DBLUEPRINT_GUARD_SKIP === '1');
+    if (bypassEnabled) {
+        return {
+            valid: true,
+            reason: 'Bypass enabled (BLUEPRINT_GUARD_SKIP=1)',
+            details: { skipReason: 'Bypass enabled (BLUEPRINT_GUARD_SKIP=1)' },
+        };
+    }
+    if (filePath && shouldSkipFile(filePath)) {
+        const skipReason = getSkipReason(filePath);
+        return { valid: true, reason: `Skipped: ${skipReason}`, details: { skipReason } };
+    }
+    return {
+        valid: true,
+        reason: 'Production file requires implementation plan (to be validated in Phase 6)',
+        details: { hasPlan: undefined },
+    };
+}
+export function parseFrontmatter(content) {
+    if (!content.startsWith('---'))
+        return null;
+    const endIndex = content.indexOf('---', 3);
+    if (endIndex === -1)
+        return null;
+    const frontmatterText = content.slice(3, endIndex).trim();
+    const result = {};
+    for (const line of frontmatterText.split('\n')) {
+        if (!line.trim() || line.startsWith('#'))
+            continue;
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        const value = line
+            .slice(colonIndex + 1)
+            .trim()
+            .replace(/^["']|["']$/g, '');
+        result[key] = value;
+    }
+    return Object.keys(result).length > 0 ? result : null;
+}
+export function isActivePlan(frontmatter) {
+    if (!frontmatter)
+        return false;
+    const status = String(frontmatter.status || '').toLowerCase();
+    return status === 'in-progress' || status === 'draft';
+}
+//# sourceMappingURL=blueprint.js.map

package/dist/esm/hooks/shared/validators/docs-governance.d.ts

@@ -0,0 +1,3 @@
+import type { ToolInput, ValidationResult } from '#hooks/shared/types';
+export declare function validateDocsGovernance(input: ToolInput, skipEnvVar?: string): ValidationResult;
+//# sourceMappingURL=docs-governance.d.ts.map

package/dist/esm/hooks/shared/validators/docs-governance.js

@@ -0,0 +1,30 @@
+import { getFilePath } from '#hooks/shared/types';
+const ALLOWED_ROOT_FILES = new Set(['docs/README.md', 'docs/FILE-TYPE-TAXONOMY.md']);
+export function validateDocsGovernance(input, skipEnvVar = 'DOCS_GOVERNANCE_SKIP') {
+    const filePath = getFilePath(input);
+    if (typeof process !== 'undefined' && process.env?.[skipEnvVar] === '1') {
+        return {
+            validator: 'docs-governance',
+            passed: true,
+            skipped: true,
+            skipReason: 'Bypass enabled',
+        };
+    }
+    if (!filePath)
+        return { validator: 'docs-governance', passed: true };
+    const normalized = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+    if (!normalized.startsWith('docs/'))
+        return { validator: 'docs-governance', passed: true };
+    if (!normalized.endsWith('.md'))
+        return { validator: 'docs-governance', passed: true };
+    const isRootLevel = /^docs\/[^/]+\.md$/.test(normalized);
+    if (isRootLevel && !ALLOWED_ROOT_FILES.has(normalized)) {
+        return {
+            validator: 'docs-governance',
+            passed: false,
+            message: `Root docs/*.md files must be README.md or FILE-TYPE-TAXONOMY.md. Got: ${normalized}`,
+        };
+    }
+    return { validator: 'docs-governance', passed: true };
+}
+//# sourceMappingURL=docs-governance.js.map

package/dist/esm/hooks/shared/worktree-root.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveActiveWorktreeRoot(cwd?: string): string;
+//# sourceMappingURL=worktree-root.d.ts.map

package/dist/esm/hooks/shared/worktree-root.js

@@ -0,0 +1,46 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+function findRepoRoot(startDir) {
+    let current = resolve(startDir);
+    for (;;) {
+        if (existsSync(join(current, 'pnpm-workspace.yaml')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            throw new Error(`Could not find repo root from: ${startDir}`);
+        current = parent;
+    }
+}
+export function resolveActiveWorktreeRoot(cwd = process.cwd()) {
+    try {
+        const gitDir = execFileSync('git', ['rev-parse', '--git-dir'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const gitCommonDir = execFileSync('git', ['rev-parse', '--git-common-dir'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (gitDir && gitCommonDir && gitDir !== gitCommonDir) {
+            const gitDirAbs = isAbsolute(gitDir) ? gitDir : resolve(cwd, gitDir);
+            const worktreeGitPath = readFileSync(resolve(gitDirAbs, 'gitdir'), 'utf8').trim();
+            if (worktreeGitPath.length > 0)
+                return dirname(worktreeGitPath);
+        }
+        const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (gitRoot.length > 0)
+            return gitRoot;
+    }
+    catch {
+        // fall through
+    }
+    return findRepoRoot(cwd);
+}
+//# sourceMappingURL=worktree-root.js.map

package/dist/esm/hooks/stop/qa-changed-files.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+export declare function getChangedFiles(projectDir: string): string[];
+export declare function filterQaFiles(files: string[]): string[];
+export declare function getTypecheckFiles(files: string[]): string[];
+export declare function findTestFiles(sourceFile: string, projectDir: string): string[];
+export declare function discoverTestFiles(changedFiles: string[], projectDir: string): string[];
+export declare function buildTypecheckCommand(files: string[]): string | null;
+export declare function buildTestCommand(files: string[]): string | null;
+export declare function runQaChecks(qaFiles: string[], projectDir: string): string[];
+export type StopHookResult = {
+    systemMessage: string;
+};
+export declare function formatStopHookOutput(result: StopHookResult): string;
+//# sourceMappingURL=qa-changed-files.d.ts.map

package/dist/esm/hooks/stop/qa-changed-files.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+import { globSync } from 'glob';
+import { execSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { basename, dirname, extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runHook } from '#hooks/shared/hook-bootstrap';
+import { isLintableFile, isSkippedPath } from '#hooks/post-tool/lint-after-edit';
+const TYPECHECKABLE_EXTENSIONS = new Set(['.ts', '.tsx']);
+export function getChangedFiles(projectDir) {
+    const unstaged = execSync('git diff --name-only', { cwd: projectDir, encoding: 'utf-8' }).trim();
+    const staged = execSync('git diff --cached --name-only', {
+        cwd: projectDir,
+        encoding: 'utf-8',
+    }).trim();
+    const all = new Set();
+    for (const line of unstaged.split('\n'))
+        if (line)
+            all.add(line);
+    for (const line of staged.split('\n'))
+        if (line)
+            all.add(line);
+    return [...all];
+}
+export function filterQaFiles(files) {
+    return files.filter((f) => isLintableFile(f) && !isSkippedPath(f));
+}
+export function getTypecheckFiles(files) {
+    return files.filter((f) => TYPECHECKABLE_EXTENSIONS.has(extname(f)));
+}
+export function findTestFiles(sourceFile, projectDir) {
+    const ext = extname(sourceFile);
+    const base = basename(sourceFile, ext);
+    const dir = dirname(sourceFile);
+    if (base.endsWith('.test') || base.endsWith('.integration.test'))
+        return [sourceFile];
+    const pattern = join(dir, `${base}.{test,integration.test}{.ts,.tsx}`);
+    return globSync(pattern, { cwd: projectDir });
+}
+export function discoverTestFiles(changedFiles, projectDir) {
+    const testFiles = new Set();
+    for (const file of changedFiles) {
+        for (const testFile of findTestFiles(file, projectDir))
+            testFiles.add(testFile);
+    }
+    return [...testFiles];
+}
+export function buildTypecheckCommand(files) {
+    if (files.length === 0)
+        return null;
+    return `just typecheck ${files.map((f) => `--file '${f}'`).join(' ')}`;
+}
+export function buildTestCommand(files) {
+    if (files.length === 0)
+        return null;
+    return `just test ${files.map((f) => `--file '${f}'`).join(' ')}`;
+}
+function runCommand(cmd, projectDir) {
+    try {
+        execSync(cmd, { cwd: projectDir, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8' });
+        return { success: true, stderr: '' };
+    }
+    catch (error) {
+        return { success: false, stderr: error.stderr || String(error) };
+    }
+}
+function runStep(label, cmd, projectDir) {
+    if (!cmd)
+        return null;
+    const result = runCommand(cmd, projectDir);
+    return result.success ? null : `${label} failed:\n${result.stderr}`;
+}
+export function runQaChecks(qaFiles, projectDir) {
+    const typecheckCmd = buildTypecheckCommand(getTypecheckFiles(qaFiles));
+    const testCmd = buildTestCommand(discoverTestFiles(qaFiles, projectDir));
+    const errors = [];
+    const typecheckErr = runStep('Typecheck', typecheckCmd, projectDir);
+    if (typecheckErr)
+        errors.push(typecheckErr);
+    const testErr = runStep('Tests', testCmd, projectDir);
+    if (testErr)
+        errors.push(testErr);
+    return errors;
+}
+export function formatStopHookOutput(result) {
+    return JSON.stringify(result);
+}
+if (process.argv[1] &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+    runHook(
+    // `Stop` is latency-sensitive and user-visible. Until webpresso grows a
+    // deferred execution plane, broad typecheck/test sweeps stay off the hot
+    // path instead of shelling synchronously at turn end.
+    (_input) => null, formatStopHookOutput);
+}
+//# sourceMappingURL=qa-changed-files.js.map

package/dist/esm/hooks/test-quality-check.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+export declare function getTestQualityCheckCwd(): string;
+export declare function resolveTestFilePath(filePath: string, cwd?: string): string;
+export declare function runTestQualityCheck(argv?: string[], cwd?: string): void;
+//# sourceMappingURL=test-quality-check.d.ts.map

package/dist/esm/hooks/test-quality-check.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { resolveActiveWorktreeRoot } from './shared/worktree-root.js';
+import { readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { isAbsolute, join } from 'node:path';
+import { findMutationGamingPatterns, findTautologicalAssertions, MUTATION_GAMING_PATTERNS, TAUTOLOGICAL_PATTERNS, } from './pretool-guard/validators/test-quality.js';
+const testFileRegex = /\.test\.(ts|tsx|js|jsx)$/;
+export function getTestQualityCheckCwd() {
+    return resolveActiveWorktreeRoot(process.cwd());
+}
+export function resolveTestFilePath(filePath, cwd = getTestQualityCheckCwd()) {
+    return isAbsolute(filePath) ? filePath : join(cwd, filePath);
+}
+export function runTestQualityCheck(argv = process.argv.slice(2), cwd = getTestQualityCheckCwd()) {
+    const testFiles = argv.filter((filePath) => testFileRegex.test(filePath));
+    if (testFiles.length === 0)
+        return;
+    let hasFailures = false;
+    const failureLines = [];
+    for (const filePath of testFiles) {
+        if (filePath.includes('test-quality.test.ts'))
+            continue;
+        try {
+            const resolvedPath = resolveTestFilePath(filePath, cwd);
+            const content = readFileSync(resolvedPath, 'utf8');
+            const gamingMatches = findMutationGamingPatterns(content, filePath);
+            if (gamingMatches.length > 0) {
+                hasFailures = true;
+                failureLines.push(`❌ ${filePath}`);
+                for (const match of gamingMatches) {
+                    failureLines.push(match.line === 0
+                        ? `  File path: ${match.pattern}`
+                        : `  Line ${match.line}: ${match.pattern}`);
+                }
+            }
+            const matches = findTautologicalAssertions(content);
+            if (matches.length > 0) {
+                hasFailures = true;
+                failureLines.push(`❌ ${filePath}`);
+                for (const match of matches)
+                    failureLines.push(`  Line ${match.line}: ${match.pattern}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Failed to read ${filePath}: ${message}`);
+            throw error;
+        }
+    }
+    if (hasFailures) {
+        console.error(`Test quality issues detected (${MUTATION_GAMING_PATTERNS.length} gaming patterns + ${TAUTOLOGICAL_PATTERNS.length} tautology patterns checked):`);
+        for (const line of failureLines)
+            console.error(line);
+        process.exit(1);
+    }
+}
+if (process.argv[1] &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+    runTestQualityCheck();
+}
+//# sourceMappingURL=test-quality-check.js.map

package/dist/esm/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * webpresso — runtime-safe public API.
+ *
+ * Pure functions, types, and schemas with no filesystem or git I/O.
+ * For Node-only features (services, symlinker, CLI), import from
+ * 'webpresso/local'.
+ *
+ * Populated in Phase 1.
+ */
+export type __WebpressoEntrypointReserved = never;
+export { analyzeBundleBudget, extractHtmlEagerJsReferences, formatBundleBudgetReport, formatBytes, installChunkLoadRecovery, } from './vite/index.js';
+export type { AnalyzeBundleBudgetOptions, BundleBudgetAsset, BundleBudgetLimits, BundleBudgetResult, BundleBudgetViolation, BundleBudgetViolationKind, ChunkLoadRecoveryEvent, ChunkLoadRecoveryStorage, ChunkLoadRecoveryTarget, InstallChunkLoadRecoveryOptions, } from './vite/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+/**
+ * webpresso — runtime-safe public API.
+ *
+ * Pure functions, types, and schemas with no filesystem or git I/O.
+ * For Node-only features (services, symlinker, CLI), import from
+ * 'webpresso/local'.
+ *
+ * Populated in Phase 1.
+ */
+export { analyzeBundleBudget, extractHtmlEagerJsReferences, formatBundleBudgetReport, formatBytes, installChunkLoadRecovery, } from './vite/index.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/lint/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Stable subpath export: `webpresso/lint`.
+ *
+ * Exposes a framework-friendly `runLint` runner that uses the `vp lint`
+ * facade. Mirrors the semantics of the `wp_lint` MCP tool but returns a
+ * typed result object directly so external scaffolders can consume it without
+ * reaching through the MCP transport.
+ */
+export interface LintIssue {
+    readonly file: string;
+    readonly line: number;
+    readonly rule: string;
+    readonly message: string;
+}
+export interface LintResult {
+    readonly passed: boolean;
+    readonly issues: readonly LintIssue[];
+    readonly exitCode: number;
+    readonly output?: string;
+    readonly parseError?: string;
+    readonly spawnError?: string;
+    readonly timedOut?: boolean;
+    readonly aborted?: boolean;
+}
+export interface RunLintOptions {
+    /** Files or glob targets to lint. When omitted, lints `.` */
+    readonly files?: readonly string[];
+    /** Apply autofixes via `vp lint --fix`. */
+    readonly fix?: boolean;
+    /** Override the resolved project root. */
+    readonly cwd?: string;
+    /** Hard cap on the spawned process. Defaults to 5 minutes. */
+    readonly timeoutMs?: number;
+    /** Optional cancellation signal propagated to the child process. */
+    readonly signal?: AbortSignal;
+}
+interface ParseOutcome {
+    readonly issues: LintIssue[];
+    readonly parseError?: string;
+}
+/**
+ * Parse oxlint's `--format=json` output (ESLint-compatible array shape) into
+ * a flat issue list. Annotates `parseError` on JSON or shape failure so the
+ * caller can distinguish "lint passed cleanly" from "we couldn't read output".
+ */
+export declare function parseOxlintIssues(stdout: string): ParseOutcome;
+/**
+ * Run lint via `vp lint` and return a structured result. Spawn failures surface
+ * explicitly via `spawnError`.
+ */
+export declare function runLint(options?: RunLintOptions): Promise<LintResult>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/lint/index.js

@@ -0,0 +1,115 @@
+/**
+ * Stable subpath export: `webpresso/lint`.
+ *
+ * Exposes a framework-friendly `runLint` runner that uses the `vp lint`
+ * facade. Mirrors the semantics of the `wp_lint` MCP tool but returns a
+ * typed result object directly so external scaffolders can consume it without
+ * reaching through the MCP transport.
+ */
+import { isRunFailure, runCommand } from '#mcp/tools/_shared/run-command';
+import { resolveProjectRoot } from '#mcp/tools/_shared/project-root';
+const DEFAULT_LINT_TIMEOUT_MS = 5 * 60 * 1_000;
+/**
+ * Parse oxlint's `--format=json` output (ESLint-compatible array shape) into
+ * a flat issue list. Annotates `parseError` on JSON or shape failure so the
+ * caller can distinguish "lint passed cleanly" from "we couldn't read output".
+ */
+export function parseOxlintIssues(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return { issues: [] };
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { issues: [], parseError: `oxlint JSON.parse failed: ${reason}` };
+    }
+    // Newer oxlint emits a wrapped object `{ diagnostics: [...] }` rather than
+    // an ESLint-shaped array. Normalize both shapes so callers see one issue list.
+    const reports = Array.isArray(parsed)
+        ? parsed
+        : normalizeWrappedReports(parsed);
+    if (!reports) {
+        return { issues: [], parseError: 'oxlint output was not a JSON array' };
+    }
+    const issues = [];
+    for (const fileReport of reports) {
+        const file = fileReport?.filePath ?? '';
+        const messages = fileReport?.messages;
+        if (!Array.isArray(messages))
+            continue;
+        for (const m of messages) {
+            issues.push({
+                file,
+                line: typeof m.line === 'number' ? m.line : 0,
+                rule: m.ruleId ?? '',
+                message: m.message ?? '',
+            });
+        }
+    }
+    return { issues };
+}
+function normalizeWrappedReports(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const wrapper = parsed;
+    const reports = wrapper.diagnostics ?? wrapper.results;
+    if (!Array.isArray(reports))
+        return null;
+    return reports.map((report) => {
+        const d = report;
+        return {
+            filePath: d.filename ?? '',
+            messages: [
+                {
+                    line: d.line ?? d.labels?.[0]?.span?.line ?? 0,
+                    ruleId: d.ruleId ?? d.code ?? 'parse',
+                    message: d.message ?? '',
+                },
+            ],
+        };
+    });
+}
+/**
+ * Run lint via `vp lint` and return a structured result. Spawn failures surface
+ * explicitly via `spawnError`.
+ */
+export async function runLint(options = {}) {
+    const cwd = resolveProjectRoot(options.cwd ? { explicitCwd: options.cwd } : {});
+    const runOptions = {
+        timeoutMs: options.timeoutMs ?? DEFAULT_LINT_TIMEOUT_MS,
+        signal: options.signal,
+        cwd,
+    };
+    const lintArgs = ['lint', '--format=json'];
+    if (options.fix)
+        lintArgs.push('--fix');
+    if (options.files && options.files.length > 0) {
+        lintArgs.push(...options.files);
+    }
+    else {
+        lintArgs.push('.');
+    }
+    const vpOutcome = await runCommand('vp', lintArgs, runOptions);
+    if (isRunFailure(vpOutcome)) {
+        return {
+            passed: false,
+            issues: [],
+            exitCode: 1,
+            spawnError: `vp lint spawn failed: ${vpOutcome.error.code ?? 'unknown'} ${vpOutcome.error.message}`,
+        };
+    }
+    const { issues, parseError } = parseOxlintIssues(vpOutcome.stdout);
+    return {
+        passed: vpOutcome.exitCode === 0,
+        issues,
+        exitCode: vpOutcome.exitCode,
+        output: vpOutcome.stderr || undefined,
+        parseError,
+        timedOut: vpOutcome.timedOut || undefined,
+        aborted: vpOutcome.aborted || undefined,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/local.d.ts

@@ -0,0 +1,19 @@
+/**
+ * webpresso/local — Node-only public API.
+ *
+ * Services, filesystem I/O, git integration, symlinker, docs-linter.
+ * Not Worker-safe. For pure functions, import from 'webpresso'.
+ *
+ * Populated in Phase 1.
+ */
+export type __WebpressoLocalEntrypointReserved = never;
+export { auditAiContracts } from './audit/ai-contracts.js';
+export { auditBlueprintLifecycle, auditCatalogDrift, auditCommitMessageFile, auditDocsFrontmatter, formatRepoAuditReport, validateCommitMessage, } from './audit/repo-guardrails.js';
+export type { BlueprintLifecycleOptions, CatalogDriftOptions, CommitMessageOptions, DocsFrontmatterOptions, RepoAuditResult, RepoAuditViolation, } from './audit/repo-guardrails.js';
+export { auditVision } from './audit/vision-doc.js';
+export type { VisionOptions, VisionRequiredSection } from './audit/vision-doc.js';
+export { analyzeViteDistBundleBudget, bundleBudgetCliHelp, parseBundleBudgetCliArgs, runBundleBudgetCli, } from './vite/local.js';
+export type { AnalyzeViteDistBundleBudgetOptions, BundleBudgetCliOptions } from './vite/local.js';
+export { buildSecretGateCommand, runSecretGateCommand } from './secret-gate/runner.js';
+export type { SecretGateCommand, SecretGateCommandOptions, SecretGateRunResult, } from './secret-gate/runner.js';
+//# sourceMappingURL=local.d.ts.map

package/dist/esm/local.js

@@ -0,0 +1,14 @@
+/**
+ * webpresso/local — Node-only public API.
+ *
+ * Services, filesystem I/O, git integration, symlinker, docs-linter.
+ * Not Worker-safe. For pure functions, import from 'webpresso'.
+ *
+ * Populated in Phase 1.
+ */
+export { auditAiContracts } from './audit/ai-contracts.js';
+export { auditBlueprintLifecycle, auditCatalogDrift, auditCommitMessageFile, auditDocsFrontmatter, formatRepoAuditReport, validateCommitMessage, } from './audit/repo-guardrails.js';
+export { auditVision } from './audit/vision-doc.js';
+export { analyzeViteDistBundleBudget, bundleBudgetCliHelp, parseBundleBudgetCliArgs, runBundleBudgetCli, } from './vite/local.js';
+export { buildSecretGateCommand, runSecretGateCommand } from './secret-gate/runner.js';
+//# sourceMappingURL=local.js.map

package/dist/esm/mcp/_tail-hints.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tail-hint rate limiting for blueprint MCP tools.
+ *
+ * Hints are static strings shown at the end of tool responses to nudge the
+ * agent toward the next logical step. Rate-limited per hint per cwd — once
+ * shown, a hint is suppressed for 7 days so it doesn't flood every response.
+ *
+ * History is persisted to `.agent/.tail-hint-history.jsonl` in the consumer
+ * repo. Each line is a JSON record: `{ hintId, cwd, ts }`.
+ */
+export declare const TAIL_HINTS: {
+    readonly PLL_PARALLEL: "Consider /pll for parallel execution.";
+    readonly VERIFY_DONE: "Run /verify to confirm done-ness before finalizing.";
+    readonly PLAN_REFINE: "Run /plan-refine to harden this blueprint.";
+    readonly AUDIT_FIX: "Run /verify or `wp audit --fix` before finalizing.";
+};
+export type TailHintId = keyof typeof TAIL_HINTS;
+/**
+ * Returns true when the hint should be shown (not shown in last 7 days).
+ */
+export declare function shouldShowHint(cwd: string, hintId: TailHintId): boolean;
+/**
+ * Records that the hint was shown. Appends to `.agent/.tail-hint-history.jsonl`.
+ */
+export declare function recordHint(cwd: string, hintId: TailHintId): void;
+/**
+ * Returns the hint string if it should be shown, otherwise null.
+ * Also records the hint if shown.
+ */
+export declare function maybeHint(cwd: string, hintId: TailHintId): string | null;
+//# sourceMappingURL=_tail-hints.d.ts.map