@martinloop/mcp 0.3.3 → 0.3.5

package/dist/vendor/contracts/identity.js

@@ -0,0 +1,30 @@
+export function cloneIdentityClaims(claims) {
+    return {
+        subject: claims.subject,
+        issuer: claims.issuer,
+        role: claims.role,
+        scopes: [...claims.scopes],
+        issuedAt: claims.issuedAt,
+        ...(claims.expiresAt ? { expiresAt: claims.expiresAt } : {}),
+        ...(claims.workspaceId ? { workspaceId: claims.workspaceId } : {}),
+        ...(claims.sessionId ? { sessionId: claims.sessionId } : {}),
+        ...(claims.metadata ? { metadata: { ...claims.metadata } } : {})
+    };
+}
+export function cloneIdentityToken(token) {
+    return {
+        schemaVersion: token.schemaVersion,
+        algorithm: token.algorithm,
+        keyId: token.keyId,
+        claims: cloneIdentityClaims(token.claims),
+        signature: token.signature
+    };
+}
+export function cloneIdentityAttestation(attestation) {
+    return {
+        valid: attestation.valid,
+        verifiedAt: attestation.verifiedAt,
+        reason: attestation.reason,
+        token: cloneIdentityToken(attestation.token)
+    };
+}

package/dist/vendor/contracts/index.d.ts

@@ -9,6 +9,7 @@ export interface LoopTask {
     objective: string;
     repoRoot?: string;
     verificationPlan: string[];
+    verificationTimeoutMs?: number;
     verificationStack?: VerificationStep[];
     mutationMode?: MutationMode;
     executionProfile?: ExecutionProfile;
@@ -73,7 +74,7 @@ export interface ReceiptScope {
     invocationRoot?: string;
     runsRoot?: string;
 }
-export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected";
+export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected" | "relocated" | "material_missing" | "selector_noncanonical";
 export interface ReceiptIntegritySummary {
     state: ReceiptIntegrityState;
     keyId?: string;
@@ -91,6 +92,29 @@ export interface LoopArtifact {
     label: string;
     uri: string;
 }
+export type CallStage = "routing" | "planning" | "execution" | "verification" | "retry" | "rollback" | "receipt";
+export type AgentRole = "manager" | "router" | "planner" | "worker" | "verifier" | "reviewer" | "fixer" | "system";
+export interface FirstDelta {
+    detected: boolean;
+    timestampMs?: number;
+    filePath?: string;
+    changeType?: "create" | "modify" | "delete" | "patch_proposed";
+    /** Elapsed ms from run start to first meaningful workspace change. */
+    timeToFirstDeltaMs?: number;
+}
+export interface RoutingEconomics {
+    preworkCostUsd: number;
+    executionCostUsd: number;
+    verificationCostUsd: number;
+    retryCostUsd: number;
+    totalCostUsd: number;
+    preworkBurnPct: number;
+    timeToFirstDeltaMs?: number;
+    firstDelta?: FirstDelta;
+    costPerAcceptedChange?: number;
+    routeRecommendation?: "same_route" | "direct_worker" | "manager_required" | "consensus_required";
+    routeRecommendationReason?: string;
+}
 export interface LoopAttempt {
     attemptId: string;
     index: number;
@@ -101,6 +125,10 @@ export interface LoopAttempt {
     summary?: string;
     failureClass?: FailureClass;
     intervention?: InterventionType;
+    /** Actionable diagnosis from failure classification, injected into the next attempt's prompt. */
+    diagnosticHint?: string;
+    /** Which stage of the run lifecycle this attempt represents. */
+    callStage?: CallStage;
 }
 export interface LoopEvent {
     eventId: string;
@@ -127,6 +155,7 @@ export interface LoopRecord {
     updatedAt: string;
     receiptScope?: ReceiptScope;
     receiptIntegrity?: ReceiptIntegritySummary;
+    routingEconomics?: RoutingEconomics;
 }
 export interface LoopRecordDraft {
     loopId?: string;
@@ -371,4 +400,13 @@ export interface RollbackOutcomeArtifact {
     error?: string;
 }
 export { createGovernanceSnapshot } from "./governance.js";
-export type { GovernanceSnapshot } from "./governance.js";
+export type { DestructiveActionPolicy, GovernanceSnapshot, PolicyProfile, TelemetryDestination } from "./governance.js";
+export { cloneExecutionPolicy } from "./execution-policy.js";
+export type { ExecutionPolicy, ExecutionPolicyCompileInput, ExecutionPolicyConfigInput, ExecutionPolicyDefaults, ExecutionPolicyProvenanceEntry, ExecutionPolicyRequestInput, RoutingPolicy, RoutingMode } from "./execution-policy.js";
+export { DEFAULT_ROUTING_POLICY } from "./execution-policy.js";
+export { cloneContextGraphSnapshot } from "./context-graph.js";
+export type { ContextGraphBuildOptions, ContextGraphEdge, ContextGraphHit, ContextGraphNode, ContextGraphNodeKind, ContextGraphSnapshot, ContextQuery } from "./context-graph.js";
+export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";
+export type { IdentityAttestation, IdentityClaims, IdentityToken } from "./identity.js";
+export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";
+export type { CircuitBreakDecision, TrajectoryAssessment, TrajectorySignal } from "./trajectory.js";

package/dist/vendor/contracts/index.js

@@ -217,3 +217,8 @@ function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
 export { createGovernanceSnapshot } from "./governance.js";
+export { cloneExecutionPolicy } from "./execution-policy.js";
+export { DEFAULT_ROUTING_POLICY } from "./execution-policy.js";
+export { cloneContextGraphSnapshot } from "./context-graph.js";
+export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";
+export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";

package/dist/vendor/contracts/observation.d.ts

@@ -0,0 +1,21 @@
+export type ChangeObservationStatus = "verified" | "mismatch" | "adapter_only" | "repo_only" | "unavailable";
+export interface ChangeObservationEvidence {
+    available: boolean;
+    changedFiles: string[];
+    diffStats?: {
+        filesChanged: number;
+        addedLines: number;
+        deletedLines: number;
+    };
+}
+export interface ChangeObservationReconciliation {
+    status: ChangeObservationStatus;
+    summary: string;
+    adapterReported: ChangeObservationEvidence;
+    repoObserved: ChangeObservationEvidence;
+    effectiveChangedFiles: string[];
+    matchedFiles: string[];
+    adapterOnlyFiles: string[];
+    repoOnlyFiles: string[];
+}
+export declare function cloneChangeObservationReconciliation(input: ChangeObservationReconciliation): ChangeObservationReconciliation;

package/dist/vendor/contracts/observation.js

@@ -0,0 +1,27 @@
+export function cloneChangeObservationReconciliation(input) {
+    return {
+        status: input.status,
+        summary: input.summary,
+        adapterReported: cloneObservationEvidence(input.adapterReported),
+        repoObserved: cloneObservationEvidence(input.repoObserved),
+        effectiveChangedFiles: [...input.effectiveChangedFiles],
+        matchedFiles: [...input.matchedFiles],
+        adapterOnlyFiles: [...input.adapterOnlyFiles],
+        repoOnlyFiles: [...input.repoOnlyFiles]
+    };
+}
+function cloneObservationEvidence(input) {
+    return {
+        available: input.available,
+        changedFiles: [...input.changedFiles],
+        ...(input.diffStats
+            ? {
+                diffStats: {
+                    filesChanged: input.diffStats.filesChanged,
+                    addedLines: input.diffStats.addedLines,
+                    deletedLines: input.diffStats.deletedLines
+                }
+            }
+            : {})
+    };
+}

package/dist/vendor/contracts/trajectory.d.ts

@@ -0,0 +1,26 @@
+import type { InterventionType } from "./index.js";
+export type TrajectoryStatus = "healthy" | "watch" | "drifting" | "stalled";
+export type TrajectoryConfidence = "low" | "medium" | "high";
+export type TrajectorySignalCode = "failure_oscillation" | "attempt_repetition" | "verification_stall" | "objective_drift";
+export interface TrajectorySignal {
+    code: TrajectorySignalCode;
+    severity: "low" | "medium" | "high";
+    summary: string;
+    attemptIndexes: number[];
+    matchedTerms?: string[];
+}
+export interface TrajectoryAssessment {
+    status: TrajectoryStatus;
+    confidence: TrajectoryConfidence;
+    summary: string;
+    signals: TrajectorySignal[];
+    recommendedIntervention?: InterventionType;
+}
+export interface CircuitBreakDecision {
+    shouldStop: boolean;
+    reason: string;
+    assessment: TrajectoryAssessment;
+    recommendedIntervention?: InterventionType;
+}
+export declare function cloneTrajectoryAssessment(assessment: TrajectoryAssessment): TrajectoryAssessment;
+export declare function cloneCircuitBreakDecision(decision: CircuitBreakDecision): CircuitBreakDecision;

package/dist/vendor/contracts/trajectory.js

@@ -0,0 +1,27 @@
+export function cloneTrajectoryAssessment(assessment) {
+    return {
+        status: assessment.status,
+        confidence: assessment.confidence,
+        summary: assessment.summary,
+        ...(assessment.recommendedIntervention
+            ? { recommendedIntervention: assessment.recommendedIntervention }
+            : {}),
+        signals: assessment.signals.map((signal) => ({
+            code: signal.code,
+            severity: signal.severity,
+            summary: signal.summary,
+            attemptIndexes: [...signal.attemptIndexes],
+            ...(signal.matchedTerms ? { matchedTerms: [...signal.matchedTerms] } : {})
+        }))
+    };
+}
+export function cloneCircuitBreakDecision(decision) {
+    return {
+        shouldStop: decision.shouldStop,
+        reason: decision.reason,
+        assessment: cloneTrajectoryAssessment(decision.assessment),
+        ...(decision.recommendedIntervention
+            ? { recommendedIntervention: decision.recommendedIntervention }
+            : {})
+    };
+}

package/dist/vendor/contracts/verification.d.ts

@@ -0,0 +1,28 @@
+export type VerifierExitReason = "passed" | "non_zero_exit" | "timed_out" | "spawn_error" | "invalid_command";
+export type VerifierStepType = "lint" | "typecheck" | "test_targeted" | "test_full" | "custom";
+export interface VerifierStepSnapshot {
+    command: string;
+    type: VerifierStepType;
+    fastFail: boolean;
+    passed: boolean;
+    exitCode: number;
+    exitReason: VerifierExitReason;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface VerifierSnapshot {
+    passed: boolean;
+    summary: string;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    stepCount: number;
+    failedStepCount: number;
+    commands: string[];
+    steps: VerifierStepSnapshot[];
+    combinedOutput?: string;
+}
+export declare function cloneVerifierSnapshot(snapshot: VerifierSnapshot): VerifierSnapshot;

package/dist/vendor/contracts/verification.js

@@ -0,0 +1,7 @@
+export function cloneVerifierSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        commands: [...snapshot.commands],
+        steps: snapshot.steps.map((step) => ({ ...step }))
+    };
+}

package/dist/vendor/core/context-graph.d.ts

@@ -0,0 +1,3 @@
+import { type ContextGraphBuildOptions, type ContextGraphHit, type ContextGraphSnapshot, type ContextQuery } from "../contracts/index.js";
+export declare function buildContextGraphSnapshot(repoRoot: string, options?: ContextGraphBuildOptions): Promise<ContextGraphSnapshot>;
+export declare function queryContextGraph(snapshot: ContextGraphSnapshot, query: ContextQuery): ContextGraphHit[];

package/dist/vendor/core/context-graph.js

@@ -0,0 +1,371 @@
+import { readdir, readFile } from "node:fs/promises";
+import { extname, join, posix, relative, resolve } from "node:path";
+import { cloneContextGraphSnapshot } from "../contracts/index.js";
+const TEXT_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".md",
+    ".yaml",
+    ".yml",
+    ".txt",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".sh"
+]);
+const IGNORED_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    "coverage",
+    ".pnpm-store",
+    ".npm-cache"
+]);
+export async function buildContextGraphSnapshot(repoRoot, options = {}) {
+    const normalizedRoot = resolve(repoRoot);
+    const maxFiles = options.maxFiles ?? 600;
+    const maxFileBytes = options.maxFileBytes ?? 96_000;
+    const nodes = [];
+    const state = { count: 0, truncated: false };
+    await walkContextGraph(normalizedRoot, normalizedRoot, nodes, state, { maxFiles, maxFileBytes });
+    const edges = buildContextGraphEdges(nodes);
+    return cloneContextGraphSnapshot({
+        schemaVersion: "martin.context-graph.v1",
+        repoRoot: normalizedRoot,
+        createdAt: new Date().toISOString(),
+        nodeCount: nodes.length,
+        edgeCount: edges.length,
+        truncated: state.truncated,
+        nodes,
+        edges
+    });
+}
+export function queryContextGraph(snapshot, query) {
+    const terms = normalizeQueryTerms(query);
+    const pathPrefix = query.pathPrefix?.replace(/\\/gu, "/").replace(/^\.\/+/u, "");
+    const limit = query.limit ?? 8;
+    return snapshot.nodes
+        .filter((node) => {
+        if (query.kinds && !query.kinds.includes(node.kind)) {
+            return false;
+        }
+        if (pathPrefix && !node.path.startsWith(pathPrefix)) {
+            return false;
+        }
+        return true;
+    })
+        .map((node) => scoreContextNode(node, terms))
+        .filter((hit) => hit !== undefined)
+        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+        .slice(0, limit);
+}
+async function walkContextGraph(repoRoot, currentDir, nodes, state, options) {
+    if (state.count >= options.maxFiles) {
+        state.truncated = true;
+        return;
+    }
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (state.count >= options.maxFiles) {
+            state.truncated = true;
+            break;
+        }
+        const absPath = join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.has(entry.name)) {
+                await walkContextGraph(repoRoot, absPath, nodes, state, options);
+            }
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const extension = extname(entry.name).toLowerCase();
+        if (!TEXT_EXTENSIONS.has(extension)) {
+            continue;
+        }
+        const content = await readFile(absPath, "utf8").catch(() => undefined);
+        if (!content || content.length > options.maxFileBytes) {
+            continue;
+        }
+        const relPath = relative(repoRoot, absPath).replace(/\\/gu, "/");
+        nodes.push(createContextNode(relPath, content));
+        state.count += 1;
+    }
+}
+function createContextNode(path, content) {
+    const kind = classifyContextNodeKind(path);
+    return {
+        nodeId: path,
+        path,
+        kind,
+        ...(inferLanguage(path) ? { language: inferLanguage(path) } : {}),
+        sizeBytes: Buffer.byteLength(content, "utf8"),
+        headings: extractHeadings(path, content),
+        symbols: extractSymbols(content),
+        keywords: extractKeywords(path, content),
+        imports: extractImports(path, content)
+    };
+}
+function buildContextGraphEdges(nodes) {
+    const paths = new Set(nodes.map((node) => node.path));
+    const edges = [];
+    for (const node of nodes) {
+        for (const importTarget of node.imports) {
+            const resolvedTarget = resolveContextImport(node.path, importTarget, paths);
+            if (resolvedTarget) {
+                edges.push({
+                    fromNodeId: node.nodeId,
+                    toNodeId: resolvedTarget,
+                    kind: "imports"
+                });
+            }
+        }
+        if (node.kind === "document") {
+            const documentTargets = node.keywords
+                .map((keyword) => nodes.find((candidate) => candidate.path !== node.path && candidate.path.includes(keyword)))
+                .filter((candidate) => candidate !== undefined)
+                .slice(0, 3);
+            for (const target of documentTargets) {
+                edges.push({
+                    fromNodeId: node.nodeId,
+                    toNodeId: target.nodeId,
+                    kind: "documents"
+                });
+            }
+        }
+    }
+    return dedupeEdges(edges);
+}
+function scoreContextNode(node, terms) {
+    if (terms.length === 0) {
+        return {
+            nodeId: node.nodeId,
+            path: node.path,
+            kind: node.kind,
+            score: 1,
+            matchedTerms: [],
+            reasons: ["default_match"]
+        };
+    }
+    let score = 0;
+    const matchedTerms = new Set();
+    const reasons = new Set();
+    for (const term of terms) {
+        if (node.path.toLowerCase().includes(term)) {
+            score += 6;
+            matchedTerms.add(term);
+            reasons.add("path");
+        }
+        if (node.keywords.includes(term)) {
+            score += 3;
+            matchedTerms.add(term);
+            reasons.add("keyword");
+        }
+        if (node.symbols.some((symbol) => symbol.toLowerCase().includes(term))) {
+            score += 5;
+            matchedTerms.add(term);
+            reasons.add("symbol");
+        }
+        if (node.headings.some((heading) => heading.toLowerCase().includes(term))) {
+            score += 4;
+            matchedTerms.add(term);
+            reasons.add("heading");
+        }
+        if (node.imports.some((importPath) => importPath.toLowerCase().includes(term))) {
+            score += 2;
+            matchedTerms.add(term);
+            reasons.add("import");
+        }
+    }
+    if (score === 0) {
+        return undefined;
+    }
+    return {
+        nodeId: node.nodeId,
+        path: node.path,
+        kind: node.kind,
+        score,
+        matchedTerms: [...matchedTerms],
+        reasons: [...reasons]
+    };
+}
+function normalizeQueryTerms(query) {
+    const rawTerms = [
+        ...(query.text ? tokenize(query.text) : []),
+        ...((query.terms ?? []).flatMap((term) => tokenize(term)))
+    ];
+    return [...new Set(rawTerms)];
+}
+function classifyContextNodeKind(path) {
+    const extension = extname(path).toLowerCase();
+    if (path.endsWith("package.json") || path.endsWith("tsconfig.json")) {
+        return "manifest";
+    }
+    if (extension === ".md" || extension === ".txt") {
+        return "document";
+    }
+    if (extension === ".sh") {
+        return "script";
+    }
+    if (extension === ".json" || extension === ".yaml" || extension === ".yml") {
+        return "config";
+    }
+    return "source_file";
+}
+function inferLanguage(path) {
+    const extension = extname(path).toLowerCase();
+    switch (extension) {
+        case ".ts":
+        case ".tsx":
+            return "typescript";
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs":
+            return "javascript";
+        case ".md":
+            return "markdown";
+        case ".json":
+            return "json";
+        case ".yaml":
+        case ".yml":
+            return "yaml";
+        case ".py":
+            return "python";
+        case ".sh":
+            return "shell";
+        default:
+            return undefined;
+    }
+}
+function extractHeadings(path, content) {
+    if (extname(path).toLowerCase() !== ".md") {
+        return [];
+    }
+    return content
+        .split(/\r?\n/gu)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("#"))
+        .map((line) => line.replace(/^#+\s*/u, "").trim())
+        .filter(Boolean)
+        .slice(0, 12);
+}
+function extractSymbols(content) {
+    const out = new Set();
+    const patterns = [
+        /export\s+(?:async\s+)?function\s+([A-Za-z0-9_]+)/gu,
+        /export\s+class\s+([A-Za-z0-9_]+)/gu,
+        /export\s+const\s+([A-Za-z0-9_]+)/gu,
+        /function\s+([A-Za-z0-9_]+)/gu,
+        /class\s+([A-Za-z0-9_]+)/gu,
+        /interface\s+([A-Za-z0-9_]+)/gu,
+        /type\s+([A-Za-z0-9_]+)/gu
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[1]) {
+                out.add(match[1]);
+            }
+        }
+    }
+    return [...out].slice(0, 16);
+}
+function extractKeywords(path, content) {
+    const out = new Set();
+    for (const part of path.split(/[\/._-]+/u)) {
+        if (part.length >= 3) {
+            out.add(part.toLowerCase());
+        }
+    }
+    for (const token of tokenize(content.split(/\r?\n/gu).slice(0, 16).join(" "))) {
+        out.add(token);
+    }
+    return [...out].slice(0, 24);
+}
+function extractImports(path, content) {
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(extname(path).toLowerCase())) {
+        return [];
+    }
+    const imports = new Set();
+    const patterns = [
+        /from\s+["']([^"']+)["']/gu,
+        /require\(\s*["']([^"']+)["']\s*\)/gu,
+        /import\(\s*["']([^"']+)["']\s*\)/gu
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            const candidate = match[1]?.trim();
+            if (candidate) {
+                imports.add(candidate);
+            }
+        }
+    }
+    return [...imports].slice(0, 24);
+}
+function resolveContextImport(fromPath, importPath, paths) {
+    if (!importPath.startsWith(".")) {
+        return undefined;
+    }
+    const fromDirectory = fromPath.includes("/") ? fromPath.slice(0, fromPath.lastIndexOf("/")) : "";
+    const base = posix.normalize(posix.join(fromDirectory, importPath)).replace(/^\.\//u, "");
+    const extensionlessBase = extname(base) ? base.slice(0, -extname(base).length) : base;
+    const candidates = [
+        base,
+        extensionlessBase,
+        `${extensionlessBase}.ts`,
+        `${extensionlessBase}.tsx`,
+        `${extensionlessBase}.js`,
+        `${extensionlessBase}.jsx`,
+        `${extensionlessBase}.md`,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.md`,
+        `${base}/index.ts`,
+        `${base}/index.tsx`,
+        `${base}/index.js`
+    ];
+    return candidates.find((candidate) => paths.has(candidate));
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    return edges.filter((edge) => {
+        const key = `${edge.kind}:${edge.fromNodeId}:${edge.toNodeId}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function tokenize(input) {
+    const normalized = input.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").toLowerCase();
+    const stopWords = new Set([
+        "the",
+        "and",
+        "for",
+        "with",
+        "from",
+        "that",
+        "this",
+        "into",
+        "only",
+        "keep",
+        "make",
+        "loop",
+        "then",
+        "when"
+    ]);
+    return [...new Set(normalized.match(/[a-z0-9_]{3,}/gu) ?? [])].filter((term) => !stopWords.has(term));
+}

package/dist/vendor/core/identity.d.ts

@@ -0,0 +1,20 @@
+import { type IdentityAttestation, type IdentityClaims, type IdentityToken } from "../contracts/index.js";
+export interface LocalIdentityAuthority {
+    keyId: string;
+    algorithm: "ed25519";
+    privateKeyPem: string;
+    publicKeyPem: string;
+}
+export declare function createLocalIdentityAuthority(input?: {
+    keyId?: string;
+}): LocalIdentityAuthority;
+export declare function issueIdentityToken(input: {
+    authority: Pick<LocalIdentityAuthority, "keyId" | "algorithm" | "privateKeyPem">;
+    claims: IdentityClaims;
+}): IdentityToken;
+export declare function verifyIdentityToken(input: {
+    token: IdentityToken;
+    publicKeyPem: string;
+    now?: string;
+}): IdentityAttestation;
+export declare function hasIdentityScope(token: IdentityToken, requiredScope: string): boolean;