@cassiomc1/forgeloop 1.13.0 → 1.14.0

package/src/integration.d.ts

@@ -39,6 +39,249 @@ export interface RepositorySearchRequest {
   assetPath?: string;
 }
 
+export type ForgeLoopBrowserVerificationStepKind = "NAVIGATE" | "CLICK" | "FILL" | "PRESS" | "WAIT_FOR";
+export type ForgeLoopBrowserVerificationAssertionKind =
+  | "VISIBLE" | "HIDDEN" | "TEXT_CONTAINS" | "TEXT_EQUALS" | "VALUE_EQUALS"
+  | "ATTRIBUTE_EQUALS" | "URL_IS" | "URL_PREFIX" | "TITLE_EQUALS";
+export type ForgeLoopBrowserVerificationStatus = "PASS" | "FAIL" | "BLOCKED";
+export type ForgeLoopBrowserVerificationCapturePolicy = "NEVER" | "ON_FAILURE" | "ALWAYS";
+export interface ForgeLoopBrowserVerificationLocator {
+  kind: "ROLE" | "LABEL" | "TEXT" | "CSS";
+  value: string;
+}
+export interface ForgeLoopBrowserVerificationStep {
+  id: string;
+  kind: ForgeLoopBrowserVerificationStepKind;
+  url?: string;
+  locator?: ForgeLoopBrowserVerificationLocator;
+  text?: string;
+  key?: string;
+  condition?: string;
+  expected?: string;
+}
+export interface ForgeLoopBrowserVerificationAssertion {
+  id: string;
+  kind: ForgeLoopBrowserVerificationAssertionKind;
+  locator?: ForgeLoopBrowserVerificationLocator;
+  attribute?: string;
+  expected?: string;
+}
+export interface ForgeLoopBrowserVerificationRequest {
+  taskId: string;
+  target: string;
+  verificationId: string;
+  requirement: string;
+  startUrl: string;
+  allowedOrigins: readonly string[];
+  viewport?: { width: number; height: number };
+  steps: readonly ForgeLoopBrowserVerificationStep[];
+  assertions: readonly ForgeLoopBrowserVerificationAssertion[];
+  capture?: { screenshot: ForgeLoopBrowserVerificationCapturePolicy };
+  timeoutMs?: number;
+}
+export interface ForgeLoopBrowserVerificationProvider {
+  id: string;
+  version?: string;
+  verify(input: ForgeLoopBrowserVerificationProviderInput): Promise<unknown> | unknown;
+}
+export interface ForgeLoopBrowserVerificationProviderInput extends ForgeLoopBrowserVerificationRequest {
+  signal: AbortSignal;
+  timeoutMs: number;
+}
+export interface ForgeLoopBrowserVerificationProviderFactoryInput {
+  signal: AbortSignal;
+  timeoutMs: number;
+  request: ForgeLoopBrowserVerificationRequest;
+}
+export type ForgeLoopBrowserVerificationProviderFactory = (input: ForgeLoopBrowserVerificationProviderFactoryInput) => ForgeLoopBrowserVerificationProvider | Promise<ForgeLoopBrowserVerificationProvider>;
+export interface ForgeLoopBrowserVerificationArtifact {
+  kind: "SCREENSHOT";
+  mimeType: "image/png" | "image/jpeg";
+  byteLength: number;
+  sha256: string;
+  ref: string;
+}
+export interface ForgeLoopBrowserVerificationResult {
+  taskId: string;
+  verificationId: string;
+  requirement: string;
+  target: string;
+  provider: { id: string; version?: string };
+  status: ForgeLoopBrowserVerificationStatus;
+  assertions: readonly { id: string; status: ForgeLoopBrowserVerificationStatus; actual?: string; snapshot?: string; message?: string }[];
+  diagnostics: readonly string[];
+  finalUrl: string;
+  navigations: readonly { url: string; kind: "NAVIGATE" | "REDIRECT" }[];
+  snapshots: readonly { kind: "ACCESSIBILITY"; text: string }[];
+  artifacts: readonly ForgeLoopBrowserVerificationArtifact[];
+  authority: "OBSERVATION";
+  evidenceAuthority: "NONE";
+  actionability: "NON_EXECUTABLE";
+  lifecycleAuthority: false;
+  completionAuthority: false;
+  persisted: false;
+  trustRole: "NON_EVIDENCE_BROWSER_VERIFICATION";
+  evidenceRequiresForgeLoopValidation: true;
+}
+
+export declare function runBrowserVerification(options: {
+  target?: string;
+  projectPath?: string;
+  taskId: string;
+  providerName: string;
+  verificationId: string;
+  requirement: string;
+  startUrl: string;
+  allowedOrigins: readonly string[];
+  steps: readonly ForgeLoopBrowserVerificationStep[];
+  assertions: readonly ForgeLoopBrowserVerificationAssertion[];
+  viewport?: { width: number; height: number };
+  capture?: { screenshot: ForgeLoopBrowserVerificationCapturePolicy };
+  timeoutMs?: number;
+  runtimeContext?: { browserVerificationProviders?: object | Map<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory> };
+}): Promise<ForgeLoopBrowserVerificationResult>;
+export declare const BROWSER_VERIFICATION_ASSERTION_KINDS: readonly ForgeLoopBrowserVerificationAssertionKind[];
+export declare const BROWSER_VERIFICATION_ASSERTION_STATUSES: readonly ForgeLoopBrowserVerificationStatus[];
+export declare const BROWSER_VERIFICATION_CAPTURE_POLICIES: readonly ForgeLoopBrowserVerificationCapturePolicy[];
+export declare const BROWSER_VERIFICATION_LIMITS: Readonly<Record<string, number>>;
+export declare const BROWSER_VERIFICATION_LOCATOR_KINDS: readonly ForgeLoopBrowserVerificationLocator["kind"][];
+export declare const BROWSER_VERIFICATION_PROVIDER_ID_PATTERN: RegExp;
+export declare const BROWSER_VERIFICATION_STEP_KINDS: readonly ForgeLoopBrowserVerificationStepKind[];
+export declare const BROWSER_VERIFICATION_TRUST: Readonly<Record<string, unknown>>;
+export declare const BROWSER_VERIFICATION_WAIT_CONDITIONS: readonly string[];
+export declare function normalizeBrowserVerificationRequestOptions(input?: Record<string, unknown>): Record<string, unknown>;
+export declare function assertBrowserVerificationProvider(provider: unknown): ForgeLoopBrowserVerificationProvider;
+export declare function assertBrowserVerificationProviderIdentity(provider: unknown, expectedId: string): ForgeLoopBrowserVerificationProvider;
+export declare function assertBrowserVerificationProviderRegistration(provider: unknown, expectedId: string): ForgeLoopBrowserVerificationProvider;
+export declare function createBrowserVerificationProviderRegistry(
+  providers?: Record<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>
+    | Map<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>,
+): Readonly<Record<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>>;
+export declare function normalizeBrowserVerificationRequest(input: Record<string, unknown>): ForgeLoopBrowserVerificationRequest;
+export declare function resolveBrowserVerificationProvider(
+  providers: Record<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>
+    | Map<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>
+    | undefined,
+  name: string,
+  input?: Partial<ForgeLoopBrowserVerificationProviderFactoryInput>,
+): Promise<ForgeLoopBrowserVerificationProvider>;
+export declare function normalizeBrowserVerificationResult(raw: unknown, options: {
+  provider: ForgeLoopBrowserVerificationProvider;
+  verificationId: string;
+  taskId: string;
+  requirement: string;
+  target: string;
+  expectedAssertions: readonly ForgeLoopBrowserVerificationAssertion[];
+  allowedOrigins: readonly string[];
+}): ForgeLoopBrowserVerificationResult;
+
+export type ForgeLoopSecurityReviewScope = "FULL" | "CHANGED" | "SELECTED";
+export type ForgeLoopSecurityReviewSeverity = "INFO" | "LOW" | "MEDIUM" | "HIGH" | "CRITICAL";
+export type ForgeLoopSecurityReviewConfidence = "LOW" | "MEDIUM" | "HIGH";
+export type ForgeLoopSecurityReviewCategory =
+  | "DEPENDENCY" | "SECRETS" | "INJECTION" | "AUTHENTICATION" | "AUTHORIZATION"
+  | "CRYPTOGRAPHY" | "CONFIGURATION" | "NETWORK" | "FILESYSTEM" | "SUPPLY_CHAIN"
+  | "UNSAFE_EXECUTION" | "OTHER";
+export interface ForgeLoopSecurityReviewRevision {
+  base?: string;
+  head?: string;
+}
+export interface ForgeLoopSecurityReviewRequest {
+  projectPath: string;
+  taskId: string;
+  reviewId: string;
+  scope: ForgeLoopSecurityReviewScope;
+  paths?: readonly string[];
+  categories?: readonly ForgeLoopSecurityReviewCategory[];
+  requirements?: readonly string[];
+  revision?: ForgeLoopSecurityReviewRevision;
+  timeoutMs?: number;
+}
+export interface ForgeLoopSecurityReviewProvider {
+  id: string;
+  version?: string;
+  review(input: ForgeLoopSecurityReviewProviderInput): Promise<unknown> | unknown;
+}
+export interface ForgeLoopSecurityReviewProviderInput extends ForgeLoopSecurityReviewRequest {
+  signal: AbortSignal;
+  timeoutMs: number;
+}
+export interface ForgeLoopSecurityReviewProviderFactoryInput {
+  signal: AbortSignal;
+  timeoutMs: number;
+  request: ForgeLoopSecurityReviewRequest;
+}
+export type ForgeLoopSecurityReviewProviderFactory = (input: ForgeLoopSecurityReviewProviderFactoryInput) => ForgeLoopSecurityReviewProvider | Promise<ForgeLoopSecurityReviewProvider>;
+export interface ForgeLoopSecurityReviewFinding {
+  id: string;
+  category: ForgeLoopSecurityReviewCategory;
+  severity: ForgeLoopSecurityReviewSeverity;
+  title: string;
+  summary: string;
+  path?: string;
+  line?: number;
+  ruleId?: string;
+  confidence?: ForgeLoopSecurityReviewConfidence;
+}
+export interface ForgeLoopSecurityReviewSummary {
+  total: number;
+  bySeverity: Readonly<Record<ForgeLoopSecurityReviewSeverity, number>>;
+  byCategory: Readonly<Record<ForgeLoopSecurityReviewCategory, number>>;
+}
+export interface ForgeLoopSecurityReviewResult {
+  taskId: string;
+  reviewId: string;
+  scope: ForgeLoopSecurityReviewScope;
+  requestedPaths: readonly string[];
+  provider: { id: string; version?: string };
+  findings: readonly ForgeLoopSecurityReviewFinding[];
+  summary: ForgeLoopSecurityReviewSummary;
+  diagnostics: readonly string[];
+  durationMs?: number;
+  authority: "OBSERVATION";
+  evidenceAuthority: "NONE";
+  actionability: "NON_EXECUTABLE";
+  lifecycleAuthority: false;
+  completionAuthority: false;
+  persisted: false;
+  trustRole: "NON_EVIDENCE_SECURITY_REVIEW";
+  evidenceRequiresForgeLoopValidation: true;
+}
+export declare function runSecurityReview(options: ForgeLoopSecurityReviewRequest & {
+  providerName: string;
+  signal?: AbortSignal;
+  runtimeContext?: { securityReviewProviders?: object | Map<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory> };
+}): Promise<ForgeLoopSecurityReviewResult>;
+export declare const SECURITY_REVIEW_CATEGORIES: readonly ForgeLoopSecurityReviewCategory[];
+export declare const SECURITY_REVIEW_CONFIDENCE: readonly ForgeLoopSecurityReviewConfidence[];
+export declare const SECURITY_REVIEW_LIMITS: Readonly<Record<string, number>>;
+export declare const SECURITY_REVIEW_PROVIDER_ID_PATTERN: RegExp;
+export declare const SECURITY_REVIEW_SCOPES: readonly ForgeLoopSecurityReviewScope[];
+export declare const SECURITY_REVIEW_SEVERITIES: readonly ForgeLoopSecurityReviewSeverity[];
+export declare const SECURITY_REVIEW_TRUST: Readonly<Record<string, unknown>>;
+export declare function assertSecurityReviewProvider(provider: unknown): ForgeLoopSecurityReviewProvider;
+export declare function assertSecurityReviewProviderIdentity(provider: unknown, options?: { expectedId?: string }): { id: string; version?: string };
+export declare function assertSecurityReviewProviderRegistration(provider: unknown, expectedId: string): ForgeLoopSecurityReviewProvider;
+export declare function createSecurityReviewProviderRegistry(
+  providers?: Record<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>
+    | Map<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>,
+): Readonly<Record<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>>;
+export declare function normalizeSecurityReviewRequest(input: Record<string, unknown>): ForgeLoopSecurityReviewRequest;
+export declare function resolveSecurityReviewProvider(
+  providers: Record<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>
+    | Map<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>
+    | undefined,
+  name: string,
+  input?: Partial<ForgeLoopSecurityReviewProviderFactoryInput>,
+): Promise<ForgeLoopSecurityReviewProvider>;
+export declare function normalizeSecurityReviewResult(raw: unknown, options: {
+  provider: ForgeLoopSecurityReviewProvider;
+  taskId: string;
+  reviewId: string;
+  scope: ForgeLoopSecurityReviewScope;
+  requestedPaths?: readonly string[];
+}): ForgeLoopSecurityReviewResult;
+
 export interface RepositorySearchSubmatch {
   start: number;
   end: number;
@@ -144,6 +387,8 @@ export interface ForgeLoopContext {
   usageProvider?: ForgeLoopUsageProvider;
   structuralQualityProviders?: Readonly<Record<string, ForgeLoopStructuralQualityProvider | ForgeLoopStructuralQualityProviderFactory>>;
   advisoryContextProviders?: Readonly<Record<string, ForgeLoopAdvisoryContextProvider | ForgeLoopAdvisoryContextProviderFactory>>;
+  browserVerificationProviders?: Readonly<Record<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>> | Map<string, ForgeLoopBrowserVerificationProvider | ForgeLoopBrowserVerificationProviderFactory>;
+  securityReviewProviders?: Readonly<Record<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>> | Map<string, ForgeLoopSecurityReviewProvider | ForgeLoopSecurityReviewProviderFactory>;
 }
 
 export interface ForgeLoopAdvisoryContextItem {
@@ -198,6 +443,74 @@ export interface ForgeLoopRipwireProviderOptions {
   expectedVersion: string;
 }
 
+/** Options for the optional, host-injected OpenSrc advisory adapter. */
+export interface ForgeLoopOpenSrcProviderOptions {
+  /** Absolute OpenSrc executable path selected by the host; ForgeLoop does not discover it. */
+  executablePath: string;
+  /** Exact version string qualified by the host and checked lazily at recall time. */
+  expectedVersion: string;
+  /** Absolute dedicated OpenSrc cache root passed through OPENSRC_HOME; must stay outside the project. */
+  cacheRoot: string;
+  /** Explicit allowlist of external package/repository specs eligible for advisory recall. */
+  sources: readonly string[];
+}
+
+/** Options for the optional, host-injected Agent Browser verification adapter. */
+export interface ForgeLoopAgentBrowserProviderOptions {
+  /** Absolute host-selected Agent Browser executable; ForgeLoop never discovers or installs it. */
+  executablePath: string;
+  /** Optional exact version token checked lazily at invocation time. */
+  expectedVersion?: string;
+  /** Optional absolute host-selected browser executable. It is never request-controlled. */
+  browserExecutablePath?: string;
+}
+
+/** Options for the optional, host-injected Vercel Emulated Services adapter. */
+export interface ForgeLoopEmulatedServicesProviderOptions {
+  /** Absolute host-selected executable; ForgeLoop never discovers or installs it. */
+  executablePath: string;
+  /** Exact supported version. Defaults to 0.11.2. */
+  expectedVersion?: "0.11.2";
+  /** Optional absolute host-owned temporary root, outside the target project. */
+  tempRoot?: string;
+  /** Optional absolute target root used to enforce temporary-state separation. */
+  targetRoot?: string;
+}
+
+export interface ForgeLoopEmulatedServicesStartRequest {
+  services: readonly string[];
+  basePort?: number;
+  seedPath?: string;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+export interface ForgeLoopEmulatedServicesObservation {
+  provider: { id: "emulated-services"; version: "0.11.2" };
+  services: readonly { id: string; endpoint: string }[];
+  status: "READY";
+  diagnostics: readonly string[];
+  authority: "OBSERVATION";
+  evidenceAuthority: "NONE";
+  lifecycleAuthority: false;
+  completionAuthority: false;
+  persisted: false;
+  cleanup: { status: "COMPLETED" };
+}
+
+export interface ForgeLoopEmulatedServicesProvider {
+  id: "emulated-services";
+  version: "0.11.2";
+  start(input: ForgeLoopEmulatedServicesStartRequest): Promise<ForgeLoopEmulatedServicesObservation>;
+}
+
+export declare function createAgentBrowserVerificationProvider(
+  options: ForgeLoopAgentBrowserProviderOptions,
+): ForgeLoopBrowserVerificationProvider;
+export declare function createEmulatedServicesProvider(
+  options: ForgeLoopEmulatedServicesProviderOptions,
+): ForgeLoopEmulatedServicesProvider;
+
 export interface ForgeLoopNormalizedAdvisoryContextResult {
   provider: {
     id: string;
@@ -320,14 +633,178 @@ export declare function buildExecutionProfileContext(input: {
   runtimeContext?: Record<string, unknown>;
 }): Promise<ForgeLoopExecutionProfileContext>;
 
+export type ForgeLoopAuditUxCategory =
+  | "LIFECYCLE" | "CONTRACT" | "ROUTING" | "GATE" | "CHECK" | "DIAGNOSTIC"
+  | "ACTION" | "APPROVAL" | "OWNERSHIP" | "COMPLETION" | "RECOVERY" | "INTEGRITY";
+export interface ForgeLoopAuditUxTimelineItem {
+  id: string;
+  sequence: number;
+  timestamp: string | null;
+  timestampQuality: "authoritative" | "unknown";
+  kind: string;
+  phase: string | null;
+  phaseQuality?: string;
+  status: string | null;
+  title: string;
+  summary: string;
+  category: ForgeLoopAuditUxCategory;
+}
+export interface ForgeLoopAuditUxCheckAttempt {
+  sequence: number | null;
+  timestamp: string | null;
+  status: string;
+  exitCode: number | null;
+  requirement: string | null;
+  verificationCycle: number | null;
+  provenance: string | null;
+  executionMode: string | null;
+}
+export interface ForgeLoopAuditUxCheck {
+  id: string;
+  requirement: string | null;
+  attemptCount: number;
+  failedAttempts: number;
+  currentResult: string | null;
+  attempts: readonly ForgeLoopAuditUxCheckAttempt[];
+}
+export interface ForgeLoopAuditUxOwnership {
+  claimState: string | null;
+  ownershipValid: boolean;
+  mutationAllowed: boolean;
+  recoveryStatus: string | null;
+  historicalWriteClaims: readonly string[];
+  effectiveWriteClaims: readonly string[];
+  reasonCodes: readonly string[];
+}
+export interface ForgeLoopAuditUxVerification {
+  checks: readonly ForgeLoopAuditUxCheck[];
+  checkCount: number;
+  totalAttempts: number;
+  failedAttempts: number;
+  coverage: readonly { requirement: string | null; status: string }[];
+}
+export interface ForgeLoopAuditUxCompletion {
+  state: "COMPLETE" | "INCOMPLETE";
+  valid: boolean;
+  requirementsSatisfied: boolean;
+  claimsReleased: boolean;
+  publicationStatus: string | null;
+  productionReadiness: string | null;
+  reasonCodes: readonly string[];
+  coverage: readonly { requirement: string | null; status: string }[];
+}
+export interface ForgeLoopAuditUxDiagnosticSummary {
+  legacyDiagnosisCount: number;
+  cases: readonly {
+    sequence: number;
+    timestamp: string | null;
+    verificationCycle: number | null;
+    diagnosticRevision: number | null;
+    failureClass: string | null;
+    informationGain: string | null;
+  }[];
+  caseCount: number;
+  interventionCount: number;
+  dispositionCount: number;
+  invalidRevisionCount: number;
+}
+export interface ForgeLoopAuditUxActions {
+  total: number;
+  byState: Readonly<Record<string, number>>;
+  byCapability: Readonly<Record<string, number>>;
+  required: number;
+  ambiguous: number;
+  failed: number;
+  verified: number;
+  trustedSatisfied: number;
+  untrustedRequired: number;
+  repeatedIdempotencyAttempts: number;
+  reconciliationCount: number;
+  eventCount: number;
+  bounded: boolean;
+}
+export interface ForgeLoopAuditUxResult {
+  schemaVersion: 1;
+  protocolVersion: number;
+  taskId: string | null;
+  readOnly: true;
+  authority: {
+    readOnly: true;
+    lifecycleAuthority: false;
+    evidenceAuthority: false;
+    completionAuthority: false;
+    mutationAuthority: false;
+    externalExecution: false;
+  };
+  health: {
+    phase: string | null;
+    protocolValid: boolean;
+    auditStatus: string;
+    reportVerdict: string | null;
+    completionStatus: string;
+    ownershipValid: boolean;
+    claimState: string | null;
+    mutationAllowed: boolean;
+    recoveryStatus: string | null;
+    currentNextAction: string | null;
+    historyQuality: string | null;
+    traceIntegrity: boolean;
+    reasonCodes: readonly string[];
+  };
+  lifecycle: {
+    phase: string | null;
+    status: string | null;
+    revision: number | null;
+    verificationCycle: number | null;
+    nextAction: string | null;
+    terminal: boolean;
+  };
+  timeline: {
+    items: readonly ForgeLoopAuditUxTimelineItem[];
+    totalAvailable: number;
+    truncated: boolean;
+    cursor: {
+      beforeSequence: number | null;
+      afterSequence: number | null;
+      nextBeforeSequence: number | null;
+      nextAfterSequence: number | null;
+    };
+  };
+  verification: ForgeLoopAuditUxVerification;
+  ownership: ForgeLoopAuditUxOwnership;
+  diagnostics: ForgeLoopAuditUxDiagnosticSummary;
+  completion: ForgeLoopAuditUxCompletion;
+  integrity: { valid: boolean; auditStatus: string; traceValid: boolean; historyValid: boolean; reasonCodes: readonly string[] };
+  history: { quality: string | null; totalEventCount: number; returnedEventCount: number; truncated: boolean };
+  actions: ForgeLoopAuditUxActions;
+  approvals: readonly {
+    approvalId: string;
+    actionId: string | null;
+    status: string;
+    decision: string | null;
+    requestedAt: string | null;
+    resolvedAt: string | null;
+    authorityKind: string | null;
+  }[];
+  recovery: { active: boolean; status: string | null; events: readonly { sequence: number; timestamp: string | null; kind: string | null }[] };
+  links: { status: "task/status"; ownership: "task/ownership"; contract: "task/contract"; auditView: "task/audit-view" };
+}
+
 export declare const FORGELOOP_INTEGRATION_API_VERSION: number;
 export declare const FORGELOOP_INTEGRATION_RUNTIME_VERSION: number;
 export declare const CLI_COMMAND_DEFINITIONS: Readonly<Record<string, ForgeLoopCommandDefinition>>;
 export declare const INTEGRATION_LIMITS: Readonly<Record<string, number>>;
+export declare const AUDIT_UX_CATEGORIES: readonly ForgeLoopAuditUxCategory[];
+export declare const AUDIT_UX_LIMITS: Readonly<Record<string, number>>;
+export declare const AUDIT_UX_SCHEMA_VERSION: 1;
 export declare const INTEGRATION_RISK_CLASSES: Readonly<Record<string, ForgeLoopRiskClass>>;
 export declare const INTEGRATION_RESOURCE_DEFINITIONS: Readonly<Record<string, { scope: string; description: string }>>;
 export declare const VERIFICATION_EXECUTION_POLICY_MODES: readonly string[];
 export declare const VERIFICATION_ISOLATION_MODES: readonly string[];
+export declare const EMULATED_SERVICES_ID: "emulated-services";
+export declare const EMULATED_SERVICES_SUPPORTED_VERSION: "0.11.2";
+export declare const EMULATED_SERVICES_PROCESS_LIMITS: Readonly<Record<string, number>>;
+export declare const EMULATED_SERVICES_ERROR_CODES: Readonly<Record<string, string>>;
 
 export declare function getForgeLoopPackageVersion(): string;
 export declare function defaultCommandInputValues(): ForgeLoopCommandInput;
@@ -345,6 +822,18 @@ export declare function executeForgeLoopCommand<T = unknown>(input: {
 }): Promise<ForgeLoopCommandEnvelope<T>>;
 export declare function getForgeLoopCapabilities(input?: { packageVersion?: string | null }): Record<string, unknown>;
 export declare function classifyForgeLoopInvocation(command: string, input?: ForgeLoopCommandInput): ForgeLoopInvocationClassification;
+export declare function readForgeLoopIntegrationResource(
+  uri: "task/audit-view",
+  input: {
+    projectPath?: string;
+    packageRoot?: string;
+    taskId: string;
+    limit?: number;
+    beforeSequence?: number;
+    afterSequence?: number;
+    categories?: readonly ForgeLoopAuditUxCategory[];
+  },
+): Promise<{ uri: "task/audit-view"; taskId: string; data: ForgeLoopAuditUxResult }>;
 export declare function readForgeLoopIntegrationResource(uri: string, input?: Record<string, unknown>): Promise<Record<string, unknown>>;
 export declare function resolveForgeLoopProjectRoot(projectPath?: string, input?: { cwd?: string }): Promise<string>;
 export declare function searchRepository(request: RepositorySearchRequest & { repoRoot: string }): Promise<RepositorySearchResult>;
@@ -370,6 +859,9 @@ export declare function recallAdvisoryContext(input: {
 export declare function createRipwireAdvisoryContextProvider(
   options: ForgeLoopRipwireProviderOptions,
 ): ForgeLoopAdvisoryContextProvider;
+export declare function createOpenSrcAdvisoryContextProvider(
+  options: ForgeLoopOpenSrcProviderOptions,
+): ForgeLoopAdvisoryContextProvider;
 export declare const ADVISORY_CONTEXT_LIMITS: Readonly<Record<string, number>>;
 export declare const ADVISORY_CONTEXT_TRUST: Readonly<Record<string, unknown>>;
 export declare function normalizeAdvisoryRecallOptions(input?: Partial<ForgeLoopAdvisoryRecallOptions>): ForgeLoopAdvisoryRecallOptions;

package/src/integration.js

@@ -12,6 +12,7 @@ import {
 import { readForgeLoopIntegrationResource, INTEGRATION_RESOURCE_DEFINITIONS } from "./core/integration-resources.js";
 import { resolveForgeLoopProjectRoot } from "./core/project-root.js";
 import { INTEGRATION_LIMITS } from "./core/integration-limits.js";
+import { AUDIT_UX_CATEGORIES, AUDIT_UX_LIMITS, AUDIT_UX_SCHEMA_VERSION } from "./core/audit-ux.js";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -40,6 +41,9 @@ export {
   readForgeLoopIntegrationResource,
   resolveForgeLoopProjectRoot,
   INTEGRATION_LIMITS,
+  AUDIT_UX_CATEGORIES,
+  AUDIT_UX_LIMITS,
+  AUDIT_UX_SCHEMA_VERSION,
   INTEGRATION_RISK_CLASSES,
   INTEGRATION_RESOURCE_DEFINITIONS,
   CLI_COMMAND_DEFINITIONS,
@@ -102,7 +106,57 @@ export {
   VERIFICATION_ISOLATION_MODES,
 } from "./core/verification-execution.js";
 export { recallAdvisoryContext } from "./core/advisory-context/service.js";
+export { runBrowserVerification } from "./core/browser-verification/service.js";
+export {
+  BROWSER_VERIFICATION_ASSERTION_KINDS,
+  BROWSER_VERIFICATION_ASSERTION_STATUSES,
+  BROWSER_VERIFICATION_CAPTURE_POLICIES,
+  BROWSER_VERIFICATION_LIMITS,
+  BROWSER_VERIFICATION_LOCATOR_KINDS,
+  BROWSER_VERIFICATION_STEP_KINDS,
+  BROWSER_VERIFICATION_TRUST,
+  BROWSER_VERIFICATION_WAIT_CONDITIONS,
+  normalizeBrowserVerificationRequestOptions,
+} from "./core/browser-verification/constants.js";
+export {
+  assertBrowserVerificationProvider,
+  assertBrowserVerificationProviderIdentity,
+  assertBrowserVerificationProviderRegistration,
+  BROWSER_VERIFICATION_PROVIDER_ID_PATTERN,
+  createBrowserVerificationProviderRegistry,
+  normalizeBrowserVerificationRequest,
+  resolveBrowserVerificationProvider,
+} from "./core/browser-verification/provider.js";
+export { normalizeBrowserVerificationResult } from "./core/browser-verification/normalize.js";
+export { runSecurityReview } from "./core/security-review/service.js";
+export {
+  SECURITY_REVIEW_CATEGORIES,
+  SECURITY_REVIEW_CONFIDENCE,
+  SECURITY_REVIEW_LIMITS,
+  SECURITY_REVIEW_SCOPES,
+  SECURITY_REVIEW_SEVERITIES,
+  SECURITY_REVIEW_TRUST,
+} from "./core/security-review/constants.js";
+export {
+  SECURITY_REVIEW_PROVIDER_ID_PATTERN,
+  assertSecurityReviewProvider,
+  assertSecurityReviewProviderIdentity,
+  assertSecurityReviewProviderRegistration,
+  createSecurityReviewProviderRegistry,
+  normalizeSecurityReviewRequest,
+  resolveSecurityReviewProvider,
+} from "./core/security-review/provider.js";
+export { normalizeSecurityReviewResult } from "./core/security-review/normalize.js";
 export { createRipwireAdvisoryContextProvider } from "./adapters/ripwire/provider.js";
+export { createOpenSrcAdvisoryContextProvider } from "./adapters/opensrc/provider.js";
+export { createAgentBrowserVerificationProvider } from "./adapters/agent-browser/provider.js";
+export {
+  createEmulatedServicesProvider,
+  EMULATED_SERVICES_ERROR_CODES,
+  EMULATED_SERVICES_ID,
+  EMULATED_SERVICES_PROCESS_LIMITS,
+  EMULATED_SERVICES_SUPPORTED_VERSION,
+} from "./adapters/emulated-services/index.js";
 export {
   ADVISORY_CONTEXT_LIMITS,
   ADVISORY_CONTEXT_TRUST,

package/src/providers/README.md

@@ -0,0 +1,47 @@
+# Experimental internal provider modules
+
+`index.js` is an internal module entry point, not a supported package subpath.
+`@cassiomc1/forgeloop/providers` is deliberately not exported. The public,
+provider-neutral capability vocabulary is advertised by `protocol-info`; the
+generic registry remains experimental and internal. See
+[`../../docs/PROVIDER_ARCHITECTURE.md`](../../docs/PROVIDER_ARCHITECTURE.md),
+[`../../docs/PROVIDERS.md`](../../docs/PROVIDERS.md), and
+[`../../PROTOCOL_INTEGRATION.md`](../../PROTOCOL_INTEGRATION.md).
+
+`createProviderRegistry({ providers })` accepts a plain object map from ID to
+provider or lazy factory. Object keys are already unique in JavaScript; there
+is no duplicate-registration contract. Providers implement `id`, `kind`, optional
+`version` and `operation(input, context)`. Factories receive the same frozen
+`context` as operations: `{ signal, timeoutMs, providerId }`.
+
+The default deadline is 10,000 ms; `timeoutMs` must be an integer from 1 through
+300,000. Each byte limit defaults to 262,144 bytes and must be an integer from 1
+through 4,194,304. Undefined options use defaults; null and coercible values do
+not. Input normalization precedes the shared factory/validation/operation/result
+deadline. Checkpoints reject results after elapsed synchronous work, but JavaScript
+running on the same event loop cannot be preempted by a timer.
+
+Timeout rejects the invocation and aborts its context. Cancellation is cooperative:
+providers owning subprocesses, browsers, requests or other resources must listen
+to `signal` and clean them up. Late factory resolution never starts an operation.
+This registry is not a sandbox for hostile executable code. Async providers must
+return native promises; arbitrary thenables are not supported. JavaScript itself
+assimilates values returned by async functions before the registry can inspect them.
+
+Input and output are detached, deeply frozen JSON snapshots. Output requires a
+plain object root; input permits any JSON root. Accessors, proxies, custom
+prototypes, symbols, non-enumerable properties, functions, undefined, non-finite
+numbers, cycles and sparse or extended arrays are rejected without invoking
+payload getters or serialization hooks. Serialization is byte-budgeted with a
+maximum depth of 64 and 100,000 visited values. Shared acyclic references are
+copied as ordinary JSON. Provider-owned originals are not frozen or returned.
+
+Reserved authority keys set to true are rejected recursively, and top-level
+`status: COMPLETE` is forbidden. These checks never turn other output into evidence
+or authority. All factory/operation exceptions normalize to
+`E_PROVIDER_EXECUTION_FAILED`, even if they carry ForgeLoop-shaped codes or were
+constructed with `providerError`; validation and timeout errors are generated
+outside that call boundary. Error messages do not reproduce provider payloads.
+
+No installation, subprocess launch, protocol mutation or persistence occurs here.
+Existing advisory and verification boundaries remain unchanged.