@bluefly/openstandardagents 0.4.5 → 0.4.6

package/dist/sdks/shared/manifest-loader.js

@@ -6,9 +6,9 @@
  * DRY: Shared loading logic
  */
 import { readFileSync } from 'fs';
-import { parse } from 'yaml';
 import { z } from 'zod';
 import { ApiVersionSchema, MetadataSchema } from './validation.js';
+import { safeParseYAML } from '../../utils/yaml-parser.js';
 const ManifestBaseSchema = z.object({
     apiVersion: ApiVersionSchema,
     kind: z.enum(['Agent', 'Task', 'Workflow']),
@@ -23,7 +23,7 @@ export class ManifestLoader {
         const content = readFileSync(filePath, 'utf-8');
         // Parse YAML/JSON
         const parsed = filePath.endsWith('.yaml') || filePath.endsWith('.yml')
-            ? parse(content)
+            ? safeParseYAML(content)
             : JSON.parse(content);
         // Validate base structure
         ManifestBaseSchema.parse(parsed);
@@ -38,7 +38,7 @@ export class ManifestLoader {
      * CRUD: Read
      */
     static loadFromString(content, schema, format = 'yaml') {
-        const parsed = format === 'yaml' ? parse(content) : JSON.parse(content);
+        const parsed = format === 'yaml' ? safeParseYAML(content) : JSON.parse(content);
         return schema.parse(parsed);
     }
 }

package/dist/sdks/shared/validation.d.ts

@@ -23,8 +23,8 @@ export declare const LLMProviderSchema: z.ZodEnum<{
     google: "google";
     azure: "azure";
     mistral: "mistral";
-    groq: "groq";
     ollama: "ollama";
+    groq: "groq";
 }>;
 export declare const LLMConfigSchema: z.ZodObject<{
     provider: z.ZodEnum<{
@@ -35,8 +35,8 @@ export declare const LLMConfigSchema: z.ZodObject<{
         google: "google";
         azure: "azure";
         mistral: "mistral";
-        groq: "groq";
         ollama: "ollama";
+        groq: "groq";
     }>;
     model: z.ZodString;
     temperature: z.ZodOptional<z.ZodNumber>;

package/dist/services/agent-card-generator.d.ts

@@ -1,12 +1,20 @@
 /**
  * Agent Card Generator
  *
- * Converts OSSA agent manifests into comprehensive .well-known/agent-card.json
- * files for universal agent discovery. The agent card is the contract that
- * bridges MCP (tools) and A2A (agents) — solving the M×N fragmentation problem.
+ * Converts OSSA agent manifests into .well-known/agent-card.json for discovery,
+ * Agent Social profile, marketplace profile, and global/GitLab registry.
  *
- * Extracts: taxonomy, model, tools, MCP servers, A2A protocol, handoffs,
- * autonomy, constraints, observability, endpoints, auth, and encryption.
+ * Every card attribute MUST come from the OSSA agent spec (metadata, spec, or
+ * extensions). No inferred or synthetic fields. Mapping:
+ * - uri, name, version, ossaVersion: metadata + apiVersion
+ * - taxonomy: metadata.agentType, agentKind, agentArchitecture; spec.taxonomy
+ * - capabilities, tools, role, model: spec + metadata.labels
+ * - mcpServers, a2aProtocol, handoffs: extensions.mcp; extensions.a2a; spec.handoffs
+ * - autonomy, constraints, observability, state, separation: spec.*
+ * - endpoints, transport, authentication, encryption: extensions.a2a
+ * - metadata (team, environment, region, description, author): metadata.*
+ * - manifestRef, manifestDigest: options or metadata.manifest_ref, metadata.manifest_digest
+ * - tokenEfficiencySummary: top-level token_efficiency
  */
 import type { OssaAgent } from '../types/index.js';
 import type { AgentCard } from '../mesh/types.js';
@@ -23,6 +31,14 @@ export interface AgentCardGeneratorOptions {
     };
     /** Set agent status */
     status?: 'healthy' | 'degraded' | 'unavailable';
+    /** URL to full OSSA manifest (single source of truth) */
+    manifestRef?: string;
+    /** Content digest of manifest (e.g. SHA-256). If not set and manifestContent is provided, can be computed. */
+    manifestDigest?: string;
+    /** Raw manifest content for computing manifestDigest when manifestDigest not provided */
+    manifestContent?: string;
+    /** Card profile: minimal, discovery, or full */
+    cardProfile?: 'minimal' | 'discovery' | 'full';
 }
 export interface AgentCardResult {
     success: boolean;
@@ -52,6 +68,10 @@ export declare class AgentCardGenerator {
     private extractTransport;
     private extractAuthentication;
     private extractEncryption;
+    private extractState;
+    private extractTokenEfficiencySummary;
+    private extractSeparation;
+    private computeManifestDigest;
     private extractMetadata;
 }
 //# sourceMappingURL=agent-card-generator.d.ts.map

package/dist/services/agent-card-generator.js

@@ -1,13 +1,22 @@
 /**
  * Agent Card Generator
  *
- * Converts OSSA agent manifests into comprehensive .well-known/agent-card.json
- * files for universal agent discovery. The agent card is the contract that
- * bridges MCP (tools) and A2A (agents) — solving the M×N fragmentation problem.
+ * Converts OSSA agent manifests into .well-known/agent-card.json for discovery,
+ * Agent Social profile, marketplace profile, and global/GitLab registry.
  *
- * Extracts: taxonomy, model, tools, MCP servers, A2A protocol, handoffs,
- * autonomy, constraints, observability, endpoints, auth, and encryption.
+ * Every card attribute MUST come from the OSSA agent spec (metadata, spec, or
+ * extensions). No inferred or synthetic fields. Mapping:
+ * - uri, name, version, ossaVersion: metadata + apiVersion
+ * - taxonomy: metadata.agentType, agentKind, agentArchitecture; spec.taxonomy
+ * - capabilities, tools, role, model: spec + metadata.labels
+ * - mcpServers, a2aProtocol, handoffs: extensions.mcp; extensions.a2a; spec.handoffs
+ * - autonomy, constraints, observability, state, separation: spec.*
+ * - endpoints, transport, authentication, encryption: extensions.a2a
+ * - metadata (team, environment, region, description, author): metadata.*
+ * - manifestRef, manifestDigest: options or metadata.manifest_ref, metadata.manifest_digest
+ * - tokenEfficiencySummary: top-level token_efficiency
  */
+import * as crypto from 'crypto';
 /**
  * Resolve a named extension block from an OSSA manifest.
  * OSSA manifests support extensions at both `spec.extensions` and top-level
@@ -15,7 +24,8 @@
  */
 function resolveExtensionBlock(manifest, extensionName) {
     const spec = manifest.spec;
-    return spec?.extensions?.[extensionName] ?? manifest.extensions?.[extensionName];
+    return (spec?.extensions?.[extensionName] ??
+        manifest.extensions?.[extensionName]);
 }
 export class AgentCardGenerator {
     /**
@@ -56,6 +66,16 @@ export class AgentCardGenerator {
         const authentication = this.extractAuthentication(manifest);
         const encryption = this.extractEncryption(manifest);
         const metadata = this.extractMetadata(manifest);
+        const state = this.extractState(manifest);
+        const tokenEfficiencySummary = this.extractTokenEfficiencySummary(manifest);
+        const separation = this.extractSeparation(manifest);
+        const metaManifest = manifest.metadata;
+        const manifestRef = options?.manifestRef ?? metaManifest?.manifest_ref;
+        const manifestDigest = options?.manifestDigest ??
+            metaManifest?.manifest_digest ??
+            (options?.manifestContent
+                ? this.computeManifestDigest(options.manifestContent)
+                : undefined);
         // Warn on empty sections
         if (capabilities.length === 0) {
             warnings.push('No capabilities found — set metadata.labels.capability, metadata.tags, or spec.capabilities');
@@ -98,6 +118,15 @@ export class AgentCardGenerator {
             ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
             // Health
             ...(options?.status ? { status: options.status } : {}),
+            // State, token efficiency, separation (SoD: projected from OSSA manifest)
+            ...(state ? { state } : {}),
+            ...(tokenEfficiencySummary ? { tokenEfficiencySummary } : {}),
+            ...(separation ? { separation } : {}),
+            // Manifest reference and integrity (from spec metadata.manifest_ref, metadata.manifest_digest or options)
+            ...(manifestRef ? { manifestRef } : {}),
+            ...(manifestDigest ? { manifestDigest } : {}),
+            // Card profile and extensions
+            ...(options?.cardProfile ? { cardProfile: options.cardProfile } : {}),
         };
         const json = JSON.stringify(card, null, 2);
         return { success: true, card, json, errors: [], warnings };
@@ -158,7 +187,7 @@ export class AgentCardGenerator {
                 const capabilityFields = capability;
                 const capabilityName = typeof capability === 'string'
                     ? capability
-                    : (capabilityFields.id || capabilityFields.name);
+                    : capabilityFields.id || capabilityFields.name;
                 if (capabilityName && !capabilities.includes(capabilityName)) {
                     capabilities.push(capabilityName);
                 }
@@ -186,16 +215,24 @@ export class AgentCardGenerator {
             .map((toolEntry) => {
             const toolFields = toolEntry;
             // Support both camelCase (inputSchema) and snake_case (input_schema)
-            const resolvedInputSchema = toolFields.inputSchema || toolFields.input_schema || toolFields.parameters;
+            const resolvedInputSchema = toolFields.inputSchema ||
+                toolFields.input_schema ||
+                toolFields.parameters;
             const resolvedOutputSchema = toolFields.outputSchema || toolFields.output_schema;
             return {
                 name: toolEntry.name,
                 description: toolEntry.description || toolEntry.name,
-                inputSchema: (resolvedInputSchema && typeof resolvedInputSchema === 'object'
+                inputSchema: (resolvedInputSchema &&
+                    typeof resolvedInputSchema === 'object'
                     ? resolvedInputSchema
-                    : { type: 'object', properties: {} }),
+                    : {
+                        type: 'object',
+                        properties: {},
+                    }),
                 ...(resolvedOutputSchema && typeof resolvedOutputSchema === 'object'
-                    ? { outputSchema: resolvedOutputSchema }
+                    ? {
+                        outputSchema: resolvedOutputSchema,
+                    }
                     : {}),
             };
         });
@@ -245,7 +282,9 @@ export class AgentCardGenerator {
             if (server.transport) {
                 descriptor.transport = {
                     type: server.transport.type || 'stdio',
-                    ...(server.transport.command ? { command: server.transport.command } : {}),
+                    ...(server.transport.command
+                        ? { command: server.transport.command }
+                        : {}),
                     ...(server.transport.args ? { args: server.transport.args } : {}),
                     ...(server.transport.url ? { url: server.transport.url } : {}),
                 };
@@ -259,7 +298,9 @@ export class AgentCardGenerator {
                 descriptor.resources = mcpResources.map((resource) => ({
                     uri: resource.uri,
                     name: resource.name,
-                    ...(resource.description ? { description: resource.description } : {}),
+                    ...(resource.description
+                        ? { description: resource.description }
+                        : {}),
                     ...(resource.mimeType ? { mimeType: resource.mimeType } : {}),
                 }));
             }
@@ -287,7 +328,9 @@ export class AgentCardGenerator {
             descriptor.agentEndpoints = a2a.endpoints.map((endpoint) => ({
                 agentId: endpoint.agentId || endpoint.id,
                 url: endpoint.url,
-                ...(endpoint.capabilities ? { capabilities: endpoint.capabilities } : {}),
+                ...(endpoint.capabilities
+                    ? { capabilities: endpoint.capabilities }
+                    : {}),
                 ...(endpoint.priority != null ? { priority: endpoint.priority } : {}),
             }));
         }
@@ -301,7 +344,9 @@ export class AgentCardGenerator {
                             name: routingRule.name,
                             condition: routingRule.condition,
                             target: routingRule.target,
-                            ...(routingRule.priority != null ? { priority: routingRule.priority } : {}),
+                            ...(routingRule.priority != null
+                                ? { priority: routingRule.priority }
+                                : {}),
                         })),
                     }
                     : {}),
@@ -325,7 +370,9 @@ export class AgentCardGenerator {
                             name: handoffRule.name,
                             condition: handoffRule.condition,
                             target: handoffRule.target,
-                            ...(handoffRule.message ? { message: handoffRule.message } : {}),
+                            ...(handoffRule.message
+                                ? { message: handoffRule.message }
+                                : {}),
                         })),
                     }
                     : {}),
@@ -342,7 +389,9 @@ export class AgentCardGenerator {
                         handlers: a2a.completionSignals.handlers.map((signalHandler) => ({
                             signal: signalHandler.signal,
                             action: signalHandler.action,
-                            ...(signalHandler.target ? { target: signalHandler.target } : {}),
+                            ...(signalHandler.target
+                                ? { target: signalHandler.target }
+                                : {}),
                         })),
                     }
                     : {}),
@@ -397,12 +446,16 @@ export class AgentCardGenerator {
         const autonomy = {};
         if (autonomyConfig.level)
             autonomy.level = autonomyConfig.level;
-        if (autonomyConfig.approval_required != null || autonomyConfig.approvalRequired != null)
-            autonomy.approvalRequired = autonomyConfig.approval_required ?? autonomyConfig.approvalRequired;
+        if (autonomyConfig.approval_required != null ||
+            autonomyConfig.approvalRequired != null)
+            autonomy.approvalRequired =
+                autonomyConfig.approval_required ?? autonomyConfig.approvalRequired;
         if (autonomyConfig.allowed_actions || autonomyConfig.allowedActions)
-            autonomy.allowedActions = autonomyConfig.allowed_actions || autonomyConfig.allowedActions;
+            autonomy.allowedActions =
+                autonomyConfig.allowed_actions || autonomyConfig.allowedActions;
         if (autonomyConfig.blocked_actions || autonomyConfig.blockedActions)
-            autonomy.blockedActions = autonomyConfig.blocked_actions || autonomyConfig.blockedActions;
+            autonomy.blockedActions =
+                autonomyConfig.blocked_actions || autonomyConfig.blockedActions;
         return Object.keys(autonomy).length > 0 ? autonomy : null;
     }
     // ─── Constraints ───────────────────────────────────────────
@@ -415,9 +468,11 @@ export class AgentCardGenerator {
         if (constraintConfig.cost) {
             constraints.cost = {};
             if (constraintConfig.cost.maxTokensPerDay != null)
-                constraints.cost.maxTokensPerDay = constraintConfig.cost.maxTokensPerDay;
+                constraints.cost.maxTokensPerDay =
+                    constraintConfig.cost.maxTokensPerDay;
             if (constraintConfig.cost.maxTokensPerRequest != null)
-                constraints.cost.maxTokensPerRequest = constraintConfig.cost.maxTokensPerRequest;
+                constraints.cost.maxTokensPerRequest =
+                    constraintConfig.cost.maxTokensPerRequest;
             if (constraintConfig.cost.maxCostPerDay != null)
                 constraints.cost.maxCostPerDay = constraintConfig.cost.maxCostPerDay;
             if (constraintConfig.cost.currency)
@@ -426,12 +481,14 @@ export class AgentCardGenerator {
         if (constraintConfig.performance) {
             constraints.performance = {};
             if (constraintConfig.performance.maxLatencySeconds != null)
-                constraints.performance.maxLatencySeconds = constraintConfig.performance.maxLatencySeconds;
+                constraints.performance.maxLatencySeconds =
+                    constraintConfig.performance.maxLatencySeconds;
             if (constraintConfig.performance.maxConcurrentRequests != null)
                 constraints.performance.maxConcurrentRequests =
                     constraintConfig.performance.maxConcurrentRequests;
             if (constraintConfig.performance.timeoutSeconds != null)
-                constraints.performance.timeoutSeconds = constraintConfig.performance.timeoutSeconds;
+                constraints.performance.timeoutSeconds =
+                    constraintConfig.performance.timeoutSeconds;
         }
         if (constraintConfig.resources) {
             constraints.resources = {};
@@ -453,11 +510,19 @@ export class AgentCardGenerator {
         const observability = {};
         if (observabilityConfig.tracing) {
             observability.tracing = {
-                ...(observabilityConfig.tracing.enabled != null ? { enabled: observabilityConfig.tracing.enabled } : {}),
-                ...(observabilityConfig.tracing.exporter || observabilityConfig.tracing.provider
-                    ? { exporter: observabilityConfig.tracing.exporter || observabilityConfig.tracing.provider }
+                ...(observabilityConfig.tracing.enabled != null
+                    ? { enabled: observabilityConfig.tracing.enabled }
+                    : {}),
+                ...(observabilityConfig.tracing.exporter ||
+                    observabilityConfig.tracing.provider
+                    ? {
+                        exporter: observabilityConfig.tracing.exporter ||
+                            observabilityConfig.tracing.provider,
+                    }
+                    : {}),
+                ...(observabilityConfig.tracing.endpoint
+                    ? { endpoint: observabilityConfig.tracing.endpoint }
                     : {}),
-                ...(observabilityConfig.tracing.endpoint ? { endpoint: observabilityConfig.tracing.endpoint } : {}),
                 ...(observabilityConfig.tracing.samplingRate != null
                     ? { samplingRate: observabilityConfig.tracing.samplingRate }
                     : {}),
@@ -465,15 +530,25 @@ export class AgentCardGenerator {
         }
         if (observabilityConfig.metrics) {
             observability.metrics = {
-                ...(observabilityConfig.metrics.enabled != null ? { enabled: observabilityConfig.metrics.enabled } : {}),
-                ...(observabilityConfig.metrics.exporter ? { exporter: observabilityConfig.metrics.exporter } : {}),
-                ...(observabilityConfig.metrics.endpoint ? { endpoint: observabilityConfig.metrics.endpoint } : {}),
+                ...(observabilityConfig.metrics.enabled != null
+                    ? { enabled: observabilityConfig.metrics.enabled }
+                    : {}),
+                ...(observabilityConfig.metrics.exporter
+                    ? { exporter: observabilityConfig.metrics.exporter }
+                    : {}),
+                ...(observabilityConfig.metrics.endpoint
+                    ? { endpoint: observabilityConfig.metrics.endpoint }
+                    : {}),
             };
         }
         if (observabilityConfig.logging) {
             observability.logging = {
-                ...(observabilityConfig.logging.level ? { level: observabilityConfig.logging.level } : {}),
-                ...(observabilityConfig.logging.format ? { format: observabilityConfig.logging.format } : {}),
+                ...(observabilityConfig.logging.level
+                    ? { level: observabilityConfig.logging.level }
+                    : {}),
+                ...(observabilityConfig.logging.format
+                    ? { format: observabilityConfig.logging.format }
+                    : {}),
             };
         }
         return Object.keys(observability).length > 0 ? observability : null;
@@ -561,6 +636,77 @@ export class AgentCardGenerator {
         }
         return { tlsRequired: true, minTlsVersion: '1.2' };
     }
+    // ─── State (projected from OSSA spec.state) ─────────────────
+    extractState(manifest) {
+        const spec = manifest.spec;
+        const stateConfig = spec?.state;
+        if (!stateConfig || typeof stateConfig !== 'object')
+            return null;
+        const state = {};
+        if (stateConfig.mode)
+            state.mode = stateConfig.mode;
+        const storage = stateConfig.storage;
+        if (storage?.type)
+            state.storageHint = storage.type;
+        if (stateConfig.session_endpoint)
+            state.sessionEndpoint = stateConfig.session_endpoint;
+        if (stateConfig.sessionEndpoint)
+            state.sessionEndpoint = stateConfig.sessionEndpoint;
+        const checkpoint = stateConfig.checkpointing;
+        if (checkpoint?.interval_seconds != null)
+            state.checkpointIntervalSeconds = checkpoint.interval_seconds;
+        if (checkpoint?.intervalSeconds != null)
+            state.checkpointIntervalSeconds = checkpoint.intervalSeconds;
+        const ext = manifest.extensions;
+        const extCheckpoint = ext?.checkpointing;
+        if (state.checkpointIntervalSeconds == null &&
+            extCheckpoint?.interval_seconds != null)
+            state.checkpointIntervalSeconds = extCheckpoint.interval_seconds;
+        if (storage?.retention)
+            state.retention = storage.retention;
+        return Object.keys(state).length > 0 ? state : null;
+    }
+    // ─── Token efficiency summary (projected from OSSA token_efficiency) ─────
+    extractTokenEfficiencySummary(manifest) {
+        const te = manifest.token_efficiency;
+        if (!te || typeof te !== 'object')
+            return null;
+        const summary = {};
+        if (te.serialization_profile)
+            summary.serializationProfile = te.serialization_profile;
+        if (te.observation_format)
+            summary.observationFormat = te.observation_format;
+        const budget = te.budget;
+        if (budget?.max_input_tokens != null)
+            summary.maxInputTokens = budget.max_input_tokens;
+        const routing = te.routing;
+        if (Array.isArray(routing?.cascade))
+            summary.cascade = routing.cascade;
+        const consolidation = te.consolidation;
+        if (consolidation?.strategy)
+            summary.consolidationStrategy = consolidation.strategy;
+        return Object.keys(summary).length > 0 ? summary : null;
+    }
+    // ─── Separation of duties (projected from OSSA spec.access and spec.separation) ─────
+    extractSeparation(manifest) {
+        const spec = manifest.spec;
+        const access = spec?.access;
+        const separationConfig = spec?.separation;
+        if (!access && !separationConfig)
+            return null;
+        const separation = {};
+        if (access?.tier)
+            separation.accessTier = access.tier;
+        if (separationConfig?.role)
+            separation.role = separationConfig.role;
+        const conflicts = separationConfig?.conflicts_with ?? separationConfig?.conflictsWith;
+        if (Array.isArray(conflicts))
+            separation.conflictsWith = conflicts;
+        return Object.keys(separation).length > 0 ? separation : null;
+    }
+    computeManifestDigest(content) {
+        return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+    }
     // ─── Metadata ──────────────────────────────────────────────
     extractMetadata(manifest) {
         const cardMetadata = {};
@@ -578,11 +724,19 @@ export class AgentCardGenerator {
         if (manifest.metadata?.author) {
             cardMetadata.author = manifest.metadata.author;
         }
+        const meta = manifest.metadata;
+        if (meta?.team)
+            cardMetadata.team = meta.team;
+        if (meta?.environment)
+            cardMetadata.environment = meta.environment;
+        if (meta?.region)
+            cardMetadata.region = meta.region;
         if (manifest.metadata?.lifecycle) {
             cardMetadata.lifecycle = manifest.metadata.lifecycle;
         }
         // Annotations
-        const manifestAnnotations = manifest.metadata?.annotations;
+        const manifestAnnotations = manifest.metadata
+            ?.annotations;
         if (manifestAnnotations) {
             cardMetadata.annotations = manifestAnnotations;
         }

package/dist/services/agents-md/agents-md-api.service.d.ts

@@ -0,0 +1,92 @@
+/**
+ * AGENTS.md API Service
+ *
+ * Implements OpenAPI operations for GET/PUT/DELETE /agents/{name}/agents-md.
+ * Used by BuildKit or any HTTP layer that exposes ossa-cli.yaml; logic lives in OSSA.
+ * Same behavior as ossa agents-md generate/validate/sync.
+ */
+import { AgentsMdService } from './agents-md.service.js';
+import { AgentsMdDiscoveryService } from './agents-md-discovery.service.js';
+import type { DiscoveredAgentsMd } from './agents-md-discovery.service.js';
+import { ManifestRepository } from '../../repositories/manifest.repository.js';
+export interface AgentsMdOptions {
+    outputPath?: string;
+    sections?: {
+        dev_environment?: {
+            enabled?: boolean;
+            custom?: string;
+        };
+        testing?: {
+            enabled?: boolean;
+            custom?: string;
+        };
+        pr_instructions?: {
+            enabled?: boolean;
+            custom?: string;
+        };
+        security?: {
+            enabled?: boolean;
+            custom?: string;
+        };
+        code_style?: {
+            enabled?: boolean;
+            custom?: string;
+        };
+    };
+}
+export interface AgentsMdContentBody {
+    content?: string;
+    options?: AgentsMdOptions;
+}
+export interface AgentsMdResponse {
+    content: string;
+    path: string;
+}
+export declare class AgentsMdApiService {
+    private readonly manifestRepo;
+    private readonly agentsMdService;
+    private readonly discoveryService;
+    constructor(manifestRepo: ManifestRepository, agentsMdService: AgentsMdService, discoveryService: AgentsMdDiscoveryService);
+    /**
+     * Discover all AGENTS.md in workspace (for update and maintenance).
+     */
+    discover(baseDir: string): Promise<DiscoveredAgentsMd[]>;
+    /**
+     * Maintain: validate and optionally regenerate discovered AGENTS.md.
+     */
+    maintain(baseDir: string, options: {
+        regenerate: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        discovered: DiscoveredAgentsMd[];
+        updated: string[];
+        skipped: string[];
+        failed: Array<{
+            path: string;
+            error: string;
+        }>;
+    }>;
+    /**
+     * Resolve manifest path for an agent by name (convention: .agents/{name}/manifest.ossa.yaml)
+     */
+    resolveManifestPath(baseDir: string, agentName: string): string;
+    /**
+     * Resolve AGENTS.md path for an agent (default: .agents/{name}/AGENTS.md)
+     */
+    resolveAgentsMdPath(baseDir: string, agentName: string, outputPath?: string): string;
+    /**
+     * GET: Return AGENTS.md content for an agent. Optionally generate from manifest if missing.
+     */
+    getAgentsMd(agentName: string, baseDir: string, options?: {
+        generate?: boolean;
+    }): Promise<AgentsMdResponse | null>;
+    /**
+     * PUT: Create or update AGENTS.md. Accepts raw content or generate from manifest with options.
+     */
+    putAgentsMd(agentName: string, baseDir: string, body: AgentsMdContentBody): Promise<AgentsMdResponse>;
+    /**
+     * DELETE: Remove AGENTS.md file for an agent.
+     */
+    deleteAgentsMd(agentName: string, baseDir: string): Promise<boolean>;
+}
+//# sourceMappingURL=agents-md-api.service.d.ts.map