@bluefly/openstandardagents 0.4.9 → 0.5.1

package/dist/types/cognition.zod.d.ts

@@ -0,0 +1,312 @@
+/**
+ * OSSA spec.cognition — Collaborative Agent Cognition Schema
+ *
+ * Defines the cognition block added to every OSSA agent manifest.
+ * Enables hypothesis broadcasting, lock/conflict detection, and
+ * NIST SP 800-53 AU-2 audit trail for cognitive state changes.
+ *
+ * @module @openstandardagents/cognition
+ * @version 0.4.0
+ */
+import { z } from 'zod';
+export declare const HypothesisStatusSchema: z.ZodEnum<{
+    forming: "forming";
+    active: "active";
+    locked: "locked";
+    superseded: "superseded";
+    rejected: "rejected";
+    completed: "completed";
+}>;
+export type HypothesisStatus = z.infer<typeof HypothesisStatusSchema>;
+export declare const CognitionEventTypeSchema: z.ZodEnum<{
+    "hypothesis.formed": "hypothesis.formed";
+    "hypothesis.updated": "hypothesis.updated";
+    "hypothesis.locked": "hypothesis.locked";
+    "hypothesis.rejected": "hypothesis.rejected";
+    "hypothesis.completed": "hypothesis.completed";
+    "conflict.detected": "conflict.detected";
+    "conflict.resolved": "conflict.resolved";
+    "alignment.checkpoint": "alignment.checkpoint";
+    "session.joined": "session.joined";
+    "session.left": "session.left";
+    "focus.changed": "focus.changed";
+}>;
+export type CognitionEventType = z.infer<typeof CognitionEventTypeSchema>;
+export declare const ActorTypeSchema: z.ZodEnum<{
+    human: "human";
+    agent: "agent";
+}>;
+export type ActorType = z.infer<typeof ActorTypeSchema>;
+export declare const HypothesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    actorId: z.ZodString;
+    actorType: z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+    }>;
+    statement: z.ZodString;
+    intent: z.ZodObject<{
+        action: z.ZodEnum<{
+            create: "create";
+            modify: "modify";
+            delete: "delete";
+            read: "read";
+            test: "test";
+            refactor: "refactor";
+            review: "review";
+            deploy: "deploy";
+            analyze: "analyze";
+        }>;
+        targetFiles: z.ZodArray<z.ZodString>;
+        targetPackages: z.ZodArray<z.ZodString>;
+        estimatedScope: z.ZodEnum<{
+            function: "function";
+            file: "file";
+            line: "line";
+            module: "module";
+            package: "package";
+        }>;
+        conflictSensitive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        forming: "forming";
+        active: "active";
+        locked: "locked";
+        superseded: "superseded";
+        rejected: "rejected";
+        completed: "completed";
+    }>;
+    confidence: z.ZodNumber;
+    supersedes: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lockedBy: z.ZodOptional<z.ZodString>;
+    lockedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Hypothesis = z.infer<typeof HypothesisSchema>;
+export declare const PresenceSignalSchema: z.ZodObject<{
+    actorId: z.ZodString;
+    actorType: z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+    }>;
+    actorLabel: z.ZodString;
+    sessionId: z.ZodString;
+    focus: z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        selection: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+        }, z.core.$strip>>;
+        package: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    activeHypothesisId: z.ZodOptional<z.ZodString>;
+    color: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        blocked: "blocked";
+        offline: "offline";
+    }>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type PresenceSignal = z.infer<typeof PresenceSignalSchema>;
+export declare const CognitionEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        "hypothesis.formed": "hypothesis.formed";
+        "hypothesis.updated": "hypothesis.updated";
+        "hypothesis.locked": "hypothesis.locked";
+        "hypothesis.rejected": "hypothesis.rejected";
+        "hypothesis.completed": "hypothesis.completed";
+        "conflict.detected": "conflict.detected";
+        "conflict.resolved": "conflict.resolved";
+        "alignment.checkpoint": "alignment.checkpoint";
+        "session.joined": "session.joined";
+        "session.left": "session.left";
+        "focus.changed": "focus.changed";
+    }>;
+    sessionId: z.ZodString;
+    actorId: z.ZodString;
+    actorType: z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+    }>;
+    hypothesisId: z.ZodOptional<z.ZodString>;
+    conflictingHypothesisIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    checkpointHypothesisId: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    affectedFiles: z.ZodArray<z.ZodString>;
+    nist: z.ZodObject<{
+        control: z.ZodDefault<z.ZodString>;
+        classification: z.ZodEnum<{
+            critical: "critical";
+            informational: "informational";
+            warning: "warning";
+        }>;
+        requiresReview: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type CognitionEvent = z.infer<typeof CognitionEventSchema>;
+export declare const SessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    gitlabIssueId: z.ZodOptional<z.ZodNumber>;
+    branch: z.ZodOptional<z.ZodString>;
+    packages: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        ended: "ended";
+    }>;
+    participants: z.ZodArray<z.ZodObject<{
+        actorId: z.ZodString;
+        actorType: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+        }>;
+        joinedAt: z.ZodString;
+        role: z.ZodEnum<{
+            owner: "owner";
+            collaborator: "collaborator";
+            observer: "observer";
+        }>;
+    }, z.core.$strip>>;
+    activeHypothesisIds: z.ZodArray<z.ZodString>;
+    alignmentCheckpoints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hypothesisId: z.ZodString;
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    wsEndpoint: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Session = z.infer<typeof SessionSchema>;
+export declare const OSSACognitionSpecSchema: z.ZodObject<{
+    sessionCapable: z.ZodDefault<z.ZodBoolean>;
+    hypothesisEmission: z.ZodDefault<z.ZodEnum<{
+        required: "required";
+        optional: "optional";
+        disabled: "disabled";
+    }>>;
+    conflictBehavior: z.ZodDefault<z.ZodEnum<{
+        warn: "warn";
+        block: "block";
+        defer: "defer";
+    }>>;
+    alignmentGate: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        human_approval: "human_approval";
+        auto_on_confidence: "auto_on_confidence";
+        peer_agent: "peer_agent";
+    }>>;
+    autoLockConfidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentHypotheses: z.ZodDefault<z.ZodNumber>;
+    cognitiveFingerprint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OSSACognitionSpec = z.infer<typeof OSSACognitionSpecSchema>;
+export declare const CreateSessionRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    gitlabIssueId: z.ZodOptional<z.ZodNumber>;
+    branch: z.ZodOptional<z.ZodString>;
+    packages: z.ZodArray<z.ZodString>;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const CreateSessionResponseSchema: z.ZodObject<{
+    session: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        gitlabIssueId: z.ZodOptional<z.ZodNumber>;
+        branch: z.ZodOptional<z.ZodString>;
+        packages: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            ended: "ended";
+        }>;
+        participants: z.ZodArray<z.ZodObject<{
+            actorId: z.ZodString;
+            actorType: z.ZodEnum<{
+                human: "human";
+                agent: "agent";
+            }>;
+            joinedAt: z.ZodString;
+            role: z.ZodEnum<{
+                owner: "owner";
+                collaborator: "collaborator";
+                observer: "observer";
+            }>;
+        }, z.core.$strip>>;
+        activeHypothesisIds: z.ZodArray<z.ZodString>;
+        alignmentCheckpoints: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            hypothesisId: z.ZodString;
+            approvedBy: z.ZodString;
+            approvedAt: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        wsEndpoint: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    joinUrl: z.ZodString;
+    wsEndpoint: z.ZodString;
+}, z.core.$strip>;
+export declare const EmitHypothesisRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    statement: z.ZodString;
+    intent: z.ZodObject<{
+        action: z.ZodEnum<{
+            create: "create";
+            modify: "modify";
+            delete: "delete";
+            read: "read";
+            test: "test";
+            refactor: "refactor";
+            review: "review";
+            deploy: "deploy";
+            analyze: "analyze";
+        }>;
+        targetFiles: z.ZodArray<z.ZodString>;
+        targetPackages: z.ZodArray<z.ZodString>;
+        estimatedScope: z.ZodEnum<{
+            function: "function";
+            file: "file";
+            line: "line";
+            module: "module";
+            package: "package";
+        }>;
+        conflictSensitive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    confidence: z.ZodNumber;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const LockHypothesisRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    hypothesisId: z.ZodString;
+    arbitratorId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConflictResolutionRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    winningHypothesisId: z.ZodString;
+    losingHypothesisIds: z.ZodArray<z.ZodString>;
+    arbitratorId: z.ZodString;
+    checkpointDescription: z.ZodString;
+}, z.core.$strip>;
+export type CreateSessionRequest = z.infer<typeof CreateSessionRequestSchema>;
+export type CreateSessionResponse = z.infer<typeof CreateSessionResponseSchema>;
+export type EmitHypothesisRequest = z.infer<typeof EmitHypothesisRequestSchema>;
+export type LockHypothesisRequest = z.infer<typeof LockHypothesisRequestSchema>;
+export type ConflictResolutionRequest = z.infer<typeof ConflictResolutionRequestSchema>;
+//# sourceMappingURL=cognition.zod.d.ts.map

package/dist/types/cognition.zod.js

@@ -0,0 +1,223 @@
+/**
+ * OSSA spec.cognition — Collaborative Agent Cognition Schema
+ *
+ * Defines the cognition block added to every OSSA agent manifest.
+ * Enables hypothesis broadcasting, lock/conflict detection, and
+ * NIST SP 800-53 AU-2 audit trail for cognitive state changes.
+ *
+ * @module @openstandardagents/cognition
+ * @version 0.4.0
+ */
+import { z } from 'zod';
+// ============================================================================
+// Enums
+// ============================================================================
+export const HypothesisStatusSchema = z.enum([
+    'forming', // Agent is analyzing — not yet committed
+    'active', // Agent is executing against this hypothesis
+    'locked', // Human or arbitrator has locked this hypothesis (consensus)
+    'superseded', // Replaced by a newer hypothesis in the same session
+    'rejected', // Explicitly rejected by arbitrator
+    'completed', // Task done, hypothesis confirmed correct
+]);
+export const CognitionEventTypeSchema = z.enum([
+    'hypothesis.formed',
+    'hypothesis.updated',
+    'hypothesis.locked',
+    'hypothesis.rejected',
+    'hypothesis.completed',
+    'conflict.detected',
+    'conflict.resolved',
+    'alignment.checkpoint',
+    'session.joined',
+    'session.left',
+    'focus.changed',
+]);
+export const ActorTypeSchema = z.enum(['human', 'agent']);
+// ============================================================================
+// Core: Hypothesis
+// ============================================================================
+export const HypothesisSchema = z.object({
+    /** Unique ID — UUIDv4 */
+    id: z.string().uuid(),
+    /** Session this hypothesis belongs to */
+    sessionId: z.string().uuid(),
+    /** OSSA agent ID or human identifier */
+    actorId: z.string().min(1),
+    actorType: ActorTypeSchema,
+    /** Plain-language statement of what the agent believes it is doing */
+    statement: z.string().min(1).max(1000),
+    /** Machine-readable intent for conflict detection */
+    intent: z.object({
+        action: z.enum([
+            'create', 'modify', 'delete', 'read', 'test',
+            'refactor', 'review', 'deploy', 'analyze',
+        ]),
+        targetFiles: z.array(z.string()),
+        targetPackages: z.array(z.string()),
+        estimatedScope: z.enum(['line', 'function', 'file', 'module', 'package']),
+        conflictSensitive: z.boolean().default(true),
+    }),
+    /** Current lifecycle status */
+    status: HypothesisStatusSchema,
+    /** Confidence score [0.0–1.0] */
+    confidence: z.number().min(0).max(1),
+    /** Reference to superseded hypothesis */
+    supersedes: z.string().uuid().optional(),
+    /** ISO 8601 timestamps */
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    /** Lock metadata */
+    lockedBy: z.string().optional(),
+    lockedAt: z.string().datetime().optional(),
+});
+// ============================================================================
+// Core: Presence Signal
+// ============================================================================
+export const PresenceSignalSchema = z.object({
+    actorId: z.string().min(1),
+    actorType: ActorTypeSchema,
+    actorLabel: z.string(),
+    sessionId: z.string().uuid(),
+    /** Current focus — what the actor is looking at / working on */
+    focus: z.object({
+        file: z.string().optional(),
+        line: z.number().int().min(1).optional(),
+        column: z.number().int().min(0).optional(),
+        selection: z.object({
+            startLine: z.number().int(),
+            endLine: z.number().int(),
+        }).optional(),
+        package: z.string().optional(),
+        scope: z.string().optional(),
+    }),
+    /** Active hypothesis ID for this actor in this session */
+    activeHypothesisId: z.string().uuid().optional(),
+    /** Hex color assigned by room */
+    color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+    status: z.enum(['active', 'idle', 'blocked', 'offline']),
+    timestamp: z.string().datetime(),
+});
+// ============================================================================
+// Core: Cognition Event (Audit Trail)
+// ============================================================================
+export const CognitionEventSchema = z.object({
+    id: z.string().uuid(),
+    type: CognitionEventTypeSchema,
+    sessionId: z.string().uuid(),
+    actorId: z.string(),
+    actorType: ActorTypeSchema,
+    /** Related hypothesis (if applicable) */
+    hypothesisId: z.string().uuid().optional(),
+    /** Conflicting hypotheses (for conflict events) */
+    conflictingHypothesisIds: z.array(z.string().uuid()).optional(),
+    /** Agreed hypothesis (for alignment checkpoint events) */
+    checkpointHypothesisId: z.string().uuid().optional(),
+    /** Human-readable description */
+    description: z.string(),
+    /** Affected files for audit trail */
+    affectedFiles: z.array(z.string()),
+    /** NIST compliance tags */
+    nist: z.object({
+        control: z.string().default('AU-2'),
+        classification: z.enum(['informational', 'warning', 'critical']),
+        requiresReview: z.boolean().default(false),
+    }),
+    timestamp: z.string().datetime(),
+});
+// ============================================================================
+// Core: Session
+// ============================================================================
+export const SessionSchema = z.object({
+    id: z.string().uuid(),
+    name: z.string().min(1).max(100),
+    /** GitLab issue (optional but recommended) */
+    gitlabIssueId: z.number().int().optional(),
+    /** Git branch */
+    branch: z.string().optional(),
+    /** Scoped packages */
+    packages: z.array(z.string()),
+    status: z.enum(['active', 'paused', 'ended']),
+    /** Current participants */
+    participants: z.array(z.object({
+        actorId: z.string(),
+        actorType: ActorTypeSchema,
+        joinedAt: z.string().datetime(),
+        role: z.enum(['owner', 'collaborator', 'observer']),
+    })),
+    /** Active hypothesis IDs */
+    activeHypothesisIds: z.array(z.string().uuid()),
+    /** Alignment checkpoints */
+    alignmentCheckpoints: z.array(z.object({
+        id: z.string().uuid(),
+        hypothesisId: z.string().uuid(),
+        approvedBy: z.string(),
+        approvedAt: z.string().datetime(),
+        description: z.string(),
+    })),
+    /** WebSocket endpoint for Yjs sync */
+    wsEndpoint: z.string().url(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    endedAt: z.string().datetime().optional(),
+});
+// ============================================================================
+// OSSA Manifest Extension: spec.cognition
+// ============================================================================
+export const OSSACognitionSpecSchema = z.object({
+    /** Whether this agent can participate in collaborative sessions */
+    sessionCapable: z.boolean().default(false),
+    /** Hypothesis emission policy */
+    hypothesisEmission: z.enum(['required', 'optional', 'disabled']).default('optional'),
+    /** Behavior on conflict detection */
+    conflictBehavior: z.enum(['block', 'warn', 'defer']).default('block'),
+    /** Approval needed to lock a hypothesis */
+    alignmentGate: z.enum([
+        'human_approval',
+        'auto_on_confidence',
+        'peer_agent',
+        'none',
+    ]).default('human_approval'),
+    /** Confidence threshold for auto_on_confidence */
+    autoLockConfidenceThreshold: z.number().min(0).max(1).default(0.95),
+    /** Max concurrent hypotheses */
+    maxConcurrentHypotheses: z.number().int().min(1).max(5).default(1),
+    /** Cognitive fingerprint — populated by platform */
+    cognitiveFingerprint: z.string().optional(),
+});
+// ============================================================================
+// Request/Response: API contracts
+// ============================================================================
+export const CreateSessionRequestSchema = z.object({
+    name: z.string().min(1).max(100),
+    gitlabIssueId: z.number().int().optional(),
+    branch: z.string().optional(),
+    packages: z.array(z.string()).min(1),
+    agentIds: z.array(z.string()).optional(),
+});
+export const CreateSessionResponseSchema = z.object({
+    session: SessionSchema,
+    joinUrl: z.string().url(),
+    wsEndpoint: z.string().url(),
+});
+export const EmitHypothesisRequestSchema = z.object({
+    sessionId: z.string().uuid(),
+    statement: z.string().min(1).max(1000),
+    intent: HypothesisSchema.shape.intent,
+    confidence: z.number().min(0).max(1),
+    supersedes: z.string().uuid().optional(),
+});
+export const LockHypothesisRequestSchema = z.object({
+    sessionId: z.string().uuid(),
+    hypothesisId: z.string().uuid(),
+    arbitratorId: z.string(),
+    reason: z.string().optional(),
+});
+export const ConflictResolutionRequestSchema = z.object({
+    sessionId: z.string().uuid(),
+    winningHypothesisId: z.string().uuid(),
+    losingHypothesisIds: z.array(z.string().uuid()),
+    arbitratorId: z.string(),
+    checkpointDescription: z.string(),
+});
+//# sourceMappingURL=cognition.zod.js.map

package/dist/types/identity.zod.d.ts

@@ -26,9 +26,9 @@ export declare const AuthenticationMethodSchema: z.ZodEnum<{
 }>;
 export declare const ServiceAccountRoleSchema: z.ZodEnum<{
     owner: "owner";
-    developer: "developer";
     guest: "guest";
     reporter: "reporter";
+    developer: "developer";
     maintainer: "maintainer";
 }>;
 export declare const TokenEncryptionSchema: z.ZodEnum<{
@@ -59,9 +59,9 @@ export declare const ServiceAccountSchema: z.ZodObject<{
     created_at: z.ZodOptional<z.ZodString>;
     roles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         owner: "owner";
-        developer: "developer";
         guest: "guest";
         reporter: "reporter";
+        developer: "developer";
         maintainer: "maintainer";
     }>>>;
 }, z.core.$strip>;
@@ -179,9 +179,9 @@ export declare const FallbackIdentitySchema: z.ZodObject<{
         created_at: z.ZodOptional<z.ZodString>;
         roles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             owner: "owner";
-            developer: "developer";
             guest: "guest";
             reporter: "reporter";
+            developer: "developer";
             maintainer: "maintainer";
         }>>>;
     }, z.core.$strip>;
@@ -363,9 +363,9 @@ export declare const IdentitySpecSchema: z.ZodObject<{
         created_at: z.ZodOptional<z.ZodString>;
         roles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             owner: "owner";
-            developer: "developer";
             guest: "guest";
             reporter: "reporter";
+            developer: "developer";
             maintainer: "maintainer";
         }>>>;
     }, z.core.$strip>;
@@ -436,9 +436,9 @@ export declare const IdentitySpecSchema: z.ZodObject<{
             created_at: z.ZodOptional<z.ZodString>;
             roles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 owner: "owner";
-                developer: "developer";
                 guest: "guest";
                 reporter: "reporter";
+                developer: "developer";
                 maintainer: "maintainer";
             }>>>;
         }, z.core.$strip>;

package/dist/types/index.d.ts

@@ -10,22 +10,61 @@ export * from './task.js';
 export { createTaskManifest, isOssaTask } from './task.js';
 export type { OssaTask, RuntimeBinding, TaskSpec } from './task.js';
 export * from './workflow.js';
-export { createStep, createWorkflowManifest, expr, isOssaWorkflow } from './workflow.js';
+export { createStep, createWorkflowManifest, expr, isOssaWorkflow, } from './workflow.js';
 export type { OssaWorkflow, WorkflowSpec, WorkflowStep } from './workflow.js';
 export * from './messaging.js';
-export type { Command, MessageEnvelope, MessagingExtension, PublishedChannel, ReliabilityConfig, RoutingRule, Subscription } from './messaging.js';
+export type { Command, MessageEnvelope, MessagingExtension, PublishedChannel, ReliabilityConfig, RoutingRule, Subscription, } from './messaging.js';
 export * from './identity.js';
-export type { Adapter, CredentialSource, GenerationContext, Principal } from './identity.js';
+export type { Adapter, CredentialSource, GenerationContext, Principal, } from './identity.js';
 export * from './architect.js';
-export type { ArchitectRecommendation, ArchitectureConstraint, Blueprint, BlueprintKind } from './architect.js';
+export type { ArchitectRecommendation, ArchitectureConstraint, Blueprint, BlueprintKind, } from './architect.js';
 export * from './security.js';
-export type { AuditConfig, DataClassification, EgressPolicy, NetworkAccessConfig, NetworkProtocol, ResourceLimits, SandboxingConfig, SandboxType, SecurityCapability, SecurityPosture, ThreatCategory, ThreatModelEntry, ThreatSeverity } from './security.js';
+export type { AuditConfig, DataClassification, EgressPolicy, NetworkAccessConfig, NetworkProtocol, ResourceLimits, SandboxingConfig, SandboxType, SecurityCapability, SecurityPosture, ThreatCategory, ThreatModelEntry, ThreatSeverity, } from './security.js';
 export { isOssaSkill } from './skill.js';
 export type { OssaSkill } from './skill.js';
+export { createRoleManifest, isOssaRole } from './role.js';
+export type { OssaRole, RoleActivation, RoleContext, RoleExtension, RoleHooks, RoleInstructions, RoleMCPServer, RoleProtocols, RoleSpec, RoleTools, } from './role.js';
 export { isOssaMCPServer } from './mcp-server-manifest.js';
 export type { OssaMCPServer } from './mcp-server-manifest.js';
+export * from './cognition.zod.js';
+export type { ActorType, CognitionEvent, CognitionEventType, ConflictResolutionRequest, CreateSessionRequest, CreateSessionResponse, EmitHypothesisRequest, Hypothesis, HypothesisStatus, LockHypothesisRequest, OSSACognitionSpec, PresenceSignal, Session, } from './cognition.zod.js';
 export * from './protocols.js';
-export type { A2AAgentCard, A2AAuthentication, A2ACapabilities, A2AProtocol, A2ASkill, ANPDiscovery, ANPProtocol, MCPCapabilities, MCPProtocol, MCPRole, MCPServerConfig, MCPTransport, ProtocolDeclarations, VerifiableCredentialRef } from './protocols.js';
+export type { A2AAgentCard, A2AAuthentication, A2ACapabilities, A2AProtocol, A2ASkill, ANPDiscovery, ANPProtocol, MCPCapabilities, MCPProtocol, MCPRole, MCPServerConfig, MCPTransport, ProtocolDeclarations, VerifiableCredentialRef, } from './protocols.js';
+/**
+ * Execution Economics Types (v0.5.1)
+ * Portable execution intent and token governance
+ */
+export interface ExecutionProfile {
+    id: string;
+    intent_class: 'micro-audit' | 'fast-route' | 'balanced-work' | 'deep-reason' | 'long-context' | 'strict-structured' | 'human-gated';
+    latency_sla_ms?: number;
+    max_cost_usd?: number;
+    max_input_tokens?: number;
+    max_output_tokens?: number;
+    max_reasoning_tokens?: number;
+    preferred_modes?: string[];
+    fallback_chain?: string[];
+    compression_policy?: 'none' | 'extractive' | 'semantic-brief' | 'schema-projection' | 'evidence-only' | 'risk-first' | 'diff-only';
+    cache_policy?: 'none' | 'content-addressed' | 'ttl';
+    provenance_mode?: 'relaxed' | 'strict';
+}
+export interface ContextPack {
+    id: string;
+    version: string;
+    description?: string;
+    token_size?: number;
+    content_hash?: string;
+    trust_score?: number;
+    permission_scope?: string[];
+}
+export interface ReplayPacket {
+    compute_tokens: number;
+    context_tokens: number;
+    execution_profile_id: string;
+    context_pack_hashes?: string[];
+    policy_decisions?: Record<string, unknown>;
+    failure_class?: string;
+}
 /**
  * Agent Taxonomy Types (v0.4.4+)
  * Defines WHO executes, WHAT they do, and HOW they're structured
@@ -495,6 +534,15 @@ export interface OssaAgent {
         team?: TeamDefinition;
         /** Child agents for delegation (v0.4.6+) */
         subagents?: SubagentDefinition[];
+        /** Execution economics (v0.5.1) */
+        economics?: {
+            execution_profile?: string;
+            context_packs?: string[];
+            token_sovereignty?: {
+                tokenization_boundary?: string;
+                context_retention?: string;
+            };
+        };
     };
     security?: SecurityPosture;
     protocols?: ProtocolDeclarations;