@aiwg/cli 2026.9.7 → 2026.9.10

package/dist/src/cli/services/deployment-verification.js

@@ -3,44 +3,56 @@ import path from 'node:path';
 import { loadGraphIndexFile } from '../../artifacts/index-reader.js';
 import { readAiwgConfig } from '../../config/aiwg-config.js';
 import { readUserRegistry } from '../../config/user-registry.js';
+import { inspectInstallation } from '../../installation/manager.mjs';
+import { getPackageRoot } from '../../channel/manager.mjs';
 import { getProviderDefinition, normalizeProviderDefinitionId, resolveProviderPathValue, } from '../../providers/provider-definitions.js';
 import { diagnoseIntegratedProviderTransformationReceipt } from '../../providers/transformation-receipt-integration.js';
 import { diagnoseWorkspaceContext, providerContextContract, } from '../../smiths/context-pipeline/workspace-context.js';
 import { USER_SCOPE_PATHS } from '../scope-resolver.js';
 const RESTART_NOTICES = {
     claude: {
+        policy: 'restart-required',
         action: 'Restart Claude Code so the running session reloads deployed agents and skills.',
         reason: 'Claude Code reads its agent and skill registries when a session starts.',
     },
     codex: {
-        action: 'Restart or reopen Codex in this workspace so it reloads deployed agents and skills.',
-        reason: 'Codex scans project agent and skill registries when a session starts.',
+        policy: 'live-refresh',
+        action: 'Reopen Codex in this workspace if a deployed skill or agent does not appear.',
+        reason: 'Codex refreshes project skills between turns — a running session exposed newly deployed skills on the next turn without a restart (#2309).',
+        fallback: 'Codex picks up newly deployed skills on the next turn. Reopen Codex in this workspace only if a deployed skill or agent is still missing after that.',
     },
     copilot: {
+        policy: 'restart-required',
         action: 'Reload the VS Code window so Copilot reloads workspace agents and instructions.',
         reason: 'Copilot caches workspace agent definitions until the VS Code window reloads.',
     },
     cursor: {
+        policy: 'restart-required',
         action: 'Reload the Cursor workspace so it reloads agents and rules.',
         reason: 'Cursor reads workspace agents and rules when the workspace opens.',
     },
     factory: {
+        policy: 'restart-required',
         action: 'Restart the Factory droid runtime so it reloads deployed droids.',
         reason: 'Factory loads its droid registry when the runtime starts.',
     },
     opencode: {
+        policy: 'restart-required',
         action: 'Restart the OpenCode session so it reloads deployed agents.',
         reason: 'OpenCode scans its agent directory when the session starts.',
     },
     openclaw: {
+        policy: 'restart-required',
         action: 'Restart OpenClaw so it reloads its home-directory registry.',
         reason: 'OpenClaw loads its home-directory registry when the process starts.',
     },
     warp: {
+        policy: 'restart-required',
         action: 'Open a fresh Warp tab so it reloads project context.',
         reason: 'Warp reads project context when a tab starts.',
     },
     windsurf: {
+        policy: 'restart-required',
         action: 'Reload Devin Desktop so it reparses project context.',
         reason: 'Devin Desktop reads the Windsurf-compatible project context when the workspace opens.',
     },
@@ -327,9 +339,16 @@ export async function verifyProviderDeployment(options) {
     const findings = [];
     const counts = emptyCounts();
     const restartNotice = RESTART_NOTICES[normalized] ?? null;
-    const restartAction = restartNotice?.action ?? null;
+    // A provider with no notice gets no restart claim, which is what it got
+    // before this field existed. The label is the absence of a known restart
+    // requirement, not a positive claim that the client refreshes live.
+    const reloadPolicy = restartNotice?.policy ?? 'live-refresh';
+    const restartRequired = reloadPolicy === 'restart-required';
+    // Only a `restart-required` provider gets an imperative restart step. A
+    // `live-refresh` provider keeps its rationale and a conditional fallback (#2309).
+    const restartAction = restartRequired ? (restartNotice?.action ?? null) : null;
     const restartReason = restartNotice?.reason ?? null;
-    const restartRequired = restartAction !== null;
+    const reloadFallback = restartRequired ? null : (restartNotice?.fallback ?? null);
     if (!definition) {
         findings.push(finding(normalized, 'provider-unknown', 'blocking', `No provider definition is available for '${options.provider}'.`, 'Choose a supported provider or repair the project-local provider adapter.'));
     }
@@ -362,12 +381,17 @@ export async function verifyProviderDeployment(options) {
             counts[flatKind] = tally.deployed;
             if (tally.unmanaged.length === 0)
                 continue;
-            const shown = tally.unmanaged.slice(0, 3).join(', ');
-            const remainder = tally.unmanaged.length - 3;
+            // Name enough of the set that the operator can judge it, and make the
+            // overwrite previewable: `--force` replaces every listed file, so it is
+            // never the answer to an unrelated budget or listing warning (#2561).
+            const shown = tally.unmanaged.slice(0, 10).join(', ');
+            const remainder = tally.unmanaged.length - 10;
+            const bundle = options.requestedBundles[0] ?? 'all';
             findings.push(finding(normalized, `unmanaged-artifacts:${flatKind}`, 'advisory', `${tally.unmanaged.length} unmanaged ${FLAT_ARTIFACT_NOUNS[flatKind]} file(s) left in place at ${artifactPaths[flatKind]}: `
                 + `${shown}${remainder > 0 ? `, and ${remainder} more` : ''}. `
-                + 'They are not managed by AIWG and were not counted as deployed.', `Re-run aiwg use ${options.requestedBundles[0] ?? 'all'} --provider ${normalized} --force to replace them, `
-                + `or delete ${artifactPaths[flatKind]} so AIWG can reclaim the directory.`, { kind: flatKind, unmanaged: tally.unmanaged }));
+                + 'They are not managed by AIWG and were not counted as deployed.', `Preview the overwrite set with aiwg use ${bundle} --provider ${normalized} --force --dry-run; `
+                + `then re-run aiwg use ${bundle} --provider ${normalized} --force to replace exactly those ${tally.unmanaged.length} file(s), `
+                + `or delete ${artifactPaths[flatKind]} so AIWG can reclaim the directory. Leave them in place if they are yours.`, { kind: flatKind, unmanaged: tally.unmanaged }));
         }
         const resolvedSkillsPath = resolveProviderPathValue(artifactPaths.skills, deploymentRoot);
         const kernelPath = options.scope === 'user'
@@ -492,6 +516,8 @@ export async function verifyProviderDeployment(options) {
         restartRequired,
         restartAction,
         restartReason,
+        reloadPolicy,
+        reloadFallback,
         counts,
         phases,
         findings,
@@ -501,7 +527,9 @@ export function buildDryRunUseResult(options) {
     const providers = options.providers.map((provider) => {
         const normalized = normalizeProviderDefinitionId(provider) ?? provider;
         const restartNotice = RESTART_NOTICES[normalized] ?? null;
-        const restartAction = restartNotice?.action ?? null;
+        const reloadPolicy = restartNotice?.policy ?? 'live-refresh';
+        const restartRequired = reloadPolicy === 'restart-required';
+        const restartAction = restartRequired ? (restartNotice?.action ?? null) : null;
         const phases = [
             phase('resolve', 'planned', true, `Would resolve ${options.projectRoot}, ${normalized}, ${options.scope} scope.`),
             phase('deploy', 'planned', true, 'Would deploy the requested managed artifact surface.'),
@@ -514,9 +542,11 @@ export function buildDryRunUseResult(options) {
             provider: normalized,
             scope: options.scope,
             outcome: 'planned',
-            restartRequired: restartAction !== null,
+            restartRequired,
             restartAction,
             restartReason: restartNotice?.reason ?? null,
+            reloadPolicy,
+            reloadFallback: restartRequired ? null : (restartNotice?.fallback ?? null),
             counts: emptyCounts(),
             phases,
             findings: [],
@@ -613,6 +643,8 @@ export async function verifyConfiguredDeployments(projectRoot, filters = {}, fra
             restartRequired: false,
             restartAction: null,
             restartReason: null,
+            reloadPolicy: 'live-refresh',
+            reloadFallback: null,
             counts: emptyCounts(),
             phases: [phase('verify', 'failed', true, 'No installed provider deployment could be resolved.')],
             findings: [finding(fallback, 'deployment-not-configured', 'blocking', 'No installed provider deployment could be resolved.', 'Run aiwg use all --provider <provider>.')],
@@ -620,6 +652,26 @@ export async function verifyConfiguredDeployments(projectRoot, filters = {}, fra
     }
     return aggregateUseDeploymentResult({ projectRoot, frameworkRoot, scope: filters.scope ?? 'project', requestedBundles: bundles, providers: results });
 }
+/**
+ * Installation identity as the probe sees it. Read-only commands keep running
+ * under recorded/actual drift (#2559); the probe names that drift so an agent
+ * reading only the JSON does not treat a blocked installation as healthy.
+ */
+function probeInstallationIdentity() {
+    try {
+        const status = inspectInstallation({ actualRoot: getPackageRoot(), createIfMissing: false });
+        return {
+            state: status.state,
+            canonical: status.identity ? { method: status.identity.method, root: status.identity.root } : null,
+            actual: { method: status.actualMethod, root: status.actualRoot },
+            drift: status.drift,
+            mutations_blocked: status.state !== 'aligned' && status.state !== 'unrecorded',
+        };
+    }
+    catch (error) {
+        return { state: 'unknown', drift: [error instanceof Error ? error.message : String(error)], mutations_blocked: true };
+    }
+}
 export async function buildDeploymentStatusProbe(projectRoot, frameworkRoot = process.env.AIWG_ROOT || projectRoot, filters = {}) {
     const result = await verifyConfiguredDeployments(projectRoot, filters, frameworkRoot);
     const notConfigured = result.requestedBundles.length === 0
@@ -631,6 +683,7 @@ export async function buildDeploymentStatusProbe(projectRoot, frameworkRoot = pr
         generated_at: result.generatedAt,
         project_root: result.projectRoot,
         engaged,
+        installation: probeInstallationIdentity(),
         status: notConfigured ? 'not-configured' : result.outcome === 'failed' ? 'needs-repair' : result.outcome,
         checks: {
             workspace_exists: await exists(path.join(projectRoot, '.aiwg')),
@@ -756,6 +809,14 @@ export function renderUseDeploymentResult(result, options = {}) {
             lines.push(...wrapParagraph(`Framework index built: ${result.discovery.builtAt}`, width));
         }
     }
+    const reloadFallbacks = result.providers
+        .filter((provider) => !provider.restartRequired && provider.reloadFallback)
+        .map((provider) => provider.reloadFallback);
+    if (reloadFallbacks.length > 0) {
+        lines.push('', 'If something is missing');
+        for (const note of reloadFallbacks)
+            lines.push(...wrapParagraph(note, width));
+    }
     const restartActions = result.providers
         .filter((provider) => provider.restartRequired && provider.restartAction)
         .map((provider) => provider.restartAction);

package/dist/src/cli/watch-service.js

@@ -6,6 +6,7 @@
  */
 import chokidar from 'chokidar';
 import * as path from 'path';
+const MAX_RECORDED_ERRORS = 20;
 /**
  * File watching service with debouncing
  */
@@ -16,6 +17,9 @@ export class WatchService {
     debounceMs = 500;
     stats;
     isRunning = false;
+    readyAt;
+    missingTargets = [];
+    recordedErrors = [];
     constructor() {
         this.stats = {
             filesWatched: 0,
@@ -48,13 +52,20 @@ export class WatchService {
         this.watcher.on('unlink', (path) => this.handleEvent('unlink', path));
         this.watcher.on('error', (error) => {
             this.stats.errors++;
+            this.recordError(error);
             console.error('Watch error:', error);
         });
         this.isRunning = true;
+        this.readyAt = undefined;
+        this.missingTargets = [];
+        this.recordedErrors = [];
         // Wait for ready
         await new Promise((resolve) => {
             if (this.watcher) {
-                this.watcher.on('ready', () => resolve());
+                this.watcher.on('ready', () => {
+                    this.readyAt = new Date();
+                    resolve();
+                });
             }
             else {
                 resolve();
@@ -67,6 +78,7 @@ export class WatchService {
         // Resolving `start()` only once every target appears in `getWatched()`
         // makes readiness mean armed.
         await this.waitUntilArmed(patterns);
+        this.missingTargets = this.unarmedTargets(patterns);
         const watched = this.watcher?.getWatched() ?? {};
         this.stats.filesWatched = Object.values(watched).reduce((sum, files) => sum + files.length, 0);
     }
@@ -90,8 +102,12 @@ export class WatchService {
     }
     /** True when chokidar reports a watch covering every requested target. */
     allTargetsArmed(patterns) {
+        return this.unarmedTargets(patterns).length === 0;
+    }
+    /** Requested targets that `getWatched()` does not yet cover. */
+    unarmedTargets(patterns) {
         if (!this.watcher) {
-            return true;
+            return [];
         }
         const watched = this.watcher.getWatched();
         // chokidar keys `getWatched()` with the spelling it was given, so resolve
@@ -106,7 +122,16 @@ export class WatchService {
         }
         // A directory target is keyed directly; a file target is listed under its
         // parent. Either spelling resolves into the same set.
-        return patterns.every((pattern) => armed.has(path.resolve(pattern)));
+        return patterns
+            .map((pattern) => path.resolve(pattern))
+            .filter((target) => !armed.has(target));
+    }
+    recordError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.recordedErrors.push(message);
+        if (this.recordedErrors.length > MAX_RECORDED_ERRORS) {
+            this.recordedErrors.splice(0, this.recordedErrors.length - MAX_RECORDED_ERRORS);
+        }
     }
     /**
      * Stop watching
@@ -157,6 +182,21 @@ export class WatchService {
     getStats() {
         return { ...this.stats };
     }
+    /**
+     * What the watcher has observed about its own lifecycle. Intended for the
+     * failure path: a caller that waited for an event that never came reports
+     * this instead of a bare "no events" (#2553).
+     */
+    getDiagnostics() {
+        return {
+            ready: this.readyAt !== undefined,
+            readyAt: this.readyAt,
+            armed: this.missingTargets.length === 0,
+            missingTargets: [...this.missingTargets],
+            errors: [...this.recordedErrors],
+            watched: this.watcher ? this.watcher.getWatched() : {},
+        };
+    }
     /**
      * Check if service is running
      */

package/dist/src/config/aiwg-config.js

@@ -35,6 +35,92 @@ export const WORKSPACE_REPO_ACTIONS = [
     'service-action',
     'destructive',
 ];
+export const PROJECT_CLASSIFICATIONS = ['private', 'sanitized', 'public'];
+/** Normalize the string-or-object `project` field to the object form. */
+/**
+ * Validate the `project` block. Accepts the bare-string form unconditionally so
+ * existing configs keep loading (#2535).
+ */
+export function validateProjectConfig(project) {
+    const errors = [];
+    if (project === undefined || typeof project === 'string')
+        return errors;
+    if (typeof project !== 'object' || project === null || Array.isArray(project)) {
+        errors.push('project: must be a string (name) or an object');
+        return errors;
+    }
+    const value = project;
+    if (value.classification !== undefined
+        && !PROJECT_CLASSIFICATIONS.includes(value.classification)) {
+        errors.push(`project.classification: must be one of ${PROJECT_CLASSIFICATIONS.join(' | ')}`);
+    }
+    for (const key of ['name', 'description']) {
+        if (value[key] !== undefined && typeof value[key] !== 'string') {
+            errors.push(`project.${key}: must be a string`);
+        }
+    }
+    if (value.pii !== undefined && typeof value.pii !== 'boolean') {
+        errors.push('project.pii: must be a boolean');
+    }
+    if (value.handling !== undefined) {
+        if (typeof value.handling !== 'object' || value.handling === null || Array.isArray(value.handling)) {
+            errors.push('project.handling: must be an object');
+        }
+        else {
+            const handling = value.handling;
+            for (const key of ['excerptable', 'publishable', 'mirror']) {
+                if (handling[key] !== undefined && typeof handling[key] !== 'boolean') {
+                    errors.push(`project.handling.${key}: must be a boolean`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+export function resolveProject(project) {
+    if (project === undefined)
+        return undefined;
+    if (typeof project === 'string')
+        return { name: project };
+    return project;
+}
+/**
+ * Handling defaults derived from the classification when not stated explicitly.
+ * A `private` repo is closed by default; anything else stays permissive, so
+ * declaring a classification never silently tightens an existing project.
+ */
+export function resolveProjectHandling(project) {
+    const closed = project?.classification === 'private';
+    return {
+        excerptable: project?.handling?.excerptable ?? !closed,
+        publishable: project?.handling?.publishable ?? !closed,
+        mirror: project?.handling?.mirror ?? !closed,
+    };
+}
+/** Deprecated spellings mapped to their current value. */
+export const FORCE_PUSH_POLICY_ALIASES = {
+    'main-only-blocked': 'own-branch-only',
+};
+/**
+ * The rename also narrowed the permission: `main-only-blocked` allowed force-push on
+ * *any* feature branch, `own-branch-only` restricts it to the agent's own. Callers
+ * surface this rather than migrating silently, because accepting the alias quietly
+ * would change what an agent is permitted to do.
+ */
+export const FORCE_PUSH_POLICY_ALIAS_NOTE = "'main-only-blocked' is a deprecated alias for 'own-branch-only'. The permission also narrowed: "
+    + 'the old value allowed force-push on any feature branch, the new one only on the agent\'s own branch.';
+/**
+ * Normalize a force-push policy, mapping deprecated spellings forward. Returns the
+ * canonical value and the alias it came from, if any.
+ */
+export function normalizeForcePushPolicy(value) {
+    if (value === undefined)
+        return { policy: undefined };
+    const alias = FORCE_PUSH_POLICY_ALIASES[value];
+    if (alias)
+        return { policy: alias, deprecatedFrom: value };
+    return { policy: value };
+}
 const DEFAULT_BRANCH_NAMING = {
     prefix_by_type: {
         feat: 'feat/{issue}-{slug}',
@@ -70,7 +156,7 @@ export function resolveDelivery(delivery) {
         committer: delivery?.committer,
         signing: delivery?.signing,
         release_signing: delivery?.release_signing,
-        force_push_policy: delivery?.force_push_policy ?? 'never',
+        force_push_policy: normalizeForcePushPolicy(delivery?.force_push_policy).policy ?? 'never',
         auto_close_issues: delivery?.auto_close_issues ?? true,
         issue_comment_on_cycle: delivery?.issue_comment_on_cycle ?? true,
     };
@@ -770,7 +856,10 @@ export async function readAiwgConfig(projectDir) {
     if (authorizationErrors.length > 0) {
         throw new Error(`Invalid .aiwg/aiwg.config:\n${authorizationErrors.map(item => item.message).join('\n')}`);
     }
-    const threatAssessmentErrors = validateThreatAssessmentConfig(parsed.security?.threatAssessment);
+    const threatAssessmentErrors = [
+        ...validateThreatAssessmentConfig(parsed.security?.threatAssessment),
+        ...validateProjectConfig(parsed.project),
+    ];
     if (threatAssessmentErrors.length > 0) {
         throw new Error(`Invalid .aiwg/aiwg.config:\n${threatAssessmentErrors.join('\n')}`);
     }
@@ -788,7 +877,10 @@ export async function readAiwgConfig(projectDir) {
  * sync so split-root health remains deterministic.
  */
 export async function writeAiwgConfig(projectDir, config) {
-    const threatAssessmentErrors = validateThreatAssessmentConfig(config.security?.threatAssessment);
+    const threatAssessmentErrors = [
+        ...validateThreatAssessmentConfig(config.security?.threatAssessment),
+        ...validateProjectConfig(config.project),
+    ];
     if (threatAssessmentErrors.length > 0) {
         throw new Error(`Invalid .aiwg/aiwg.config:\n${threatAssessmentErrors.join('\n')}`);
     }

package/dist/src/config/cli.js

@@ -142,6 +142,14 @@ async function handleSet(config, args) {
 // Set validates enum membership for known fields (delivery.mode,
 // delivery.merge_style, delivery.force_push_policy, remotes.issue_provider)
 // before writing.
+/** Deprecated values accepted on `set` and normalized to their current spelling. */
+const ENUM_ALIASES = {
+    'delivery.force_push_policy': { 'main-only-blocked': 'own-branch-only' },
+};
+/** Extra context printed alongside an alias normalization, where semantics also changed. */
+const ENUM_ALIAS_NOTES = {
+    'delivery.force_push_policy': "The permission also narrowed: the old value allowed force-push on any feature branch, the new one only on the agent's own branch.",
+};
 const ENUM_RULES = {
     'delivery.mode': ['direct', 'feature-branch', 'pr-required'],
     'delivery.merge_style': ['rebase-merge', 'squash', 'merge', 'fast-forward-only'],
@@ -210,8 +218,15 @@ async function projectConfigGet(key, args) {
 async function projectConfigSet(key, raw, args) {
     const { readAiwgConfig, writeAiwgConfig, getProjectDir, emptyConfig, validateExternalLinks, } = await import('./aiwg-config.js');
     const projectDir = getProjectDir(undefined, args);
-    // Validate enum fields before writing
+    // Validate enum fields before writing. Deprecated spellings normalize forward with a
+    // notice rather than failing, so a config written before a rename stays settable (#2532).
     const allowed = ENUM_RULES[key];
+    const aliased = ENUM_ALIASES[key]?.[raw];
+    if (aliased) {
+        process.stderr.write(`Note: '${raw}' is a deprecated alias for '${aliased}'; writing '${aliased}'.\n`
+            + (ENUM_ALIAS_NOTES[key] ? `      ${ENUM_ALIAS_NOTES[key]}\n` : ''));
+        raw = aliased;
+    }
     if (allowed && !allowed.includes(raw)) {
         throw new AiwgError({
             code: 'ERR_INVALID_VALUE',

package/dist/src/config/gitignore.js

@@ -24,6 +24,9 @@ const GITIGNORE_PROBE_BASENAME = '.aiwg-ignore-probe';
  */
 export const AIWG_RUNTIME_PATTERNS = [
     '.aiwg/working/',
+    // Transactional preimages written before AIWG rewrites operator files.
+    // Recoverable local evidence, not project content (#2542).
+    '.aiwg/backups/',
     // .aiwg/.index/ is the artifact graph index (JSON nodes/edges + checksum
     // manifest). It is a pure build artifact, fully regenerable from corpus
     // content via `aiwg index build --all`, so it is ignored rather than committed.
@@ -56,6 +59,8 @@ export const PROVIDER_CONVENTIONAL_PATTERNS = [
  */
 export const CLAUDE_SESSION_PATTERNS = [
     '.claude/settings.local.json',
+    // Timestamped backups AIWG writes before merging hook entries (#2542).
+    '.claude/settings.json.bak.*',
 ];
 /** All recommended patterns combined */
 export const ALL_RECOMMENDED_PATTERNS = [

package/dist/src/dataset/fortemi-capability.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Independent AIWG implementation of the Fortemi dataset capability wire rules
+ * (Fortemi/fortemi-react#422 validation revision 1.0.1). AIWG pins the authority
+ * schema and vectors but never imports the producer's validator, so agreement is
+ * established by shared vectors rather than by shared code.
+ */
+export declare const FORTEMI_CAPABILITY_CONTRACT = "fortemi.dataset-execution-capabilities/v1";
+export declare const FORTEMI_CAPABILITY_SCHEMA_MAJOR = 1;
+export interface FortemiCapabilityDeclaration {
+    id: string;
+    version: string;
+    status: "supported" | "experimental" | "unsupported";
+    limits?: Record<string, number>;
+    evidence: string[];
+}
+export interface FortemiCapabilityDescriptor {
+    contract: string;
+    schemaVersion: string;
+    runtime: {
+        id: string;
+        version: string;
+        plane: string;
+        dataClass: string;
+        maturity: string;
+    };
+    guarantees: Record<string, string>;
+    capabilities: FortemiCapabilityDeclaration[];
+    evidence: Array<{
+        id: string;
+        kind: string;
+        uri: string;
+        digest?: string;
+    }>;
+}
+export interface FortemiCapabilityRequirement {
+    id: string;
+    minimumVersion?: string;
+    minimumLimits?: Record<string, number>;
+    fallback?: string[];
+}
+export interface FortemiCapabilityRequest {
+    contract: string;
+    required: FortemiCapabilityRequirement[];
+    optional?: FortemiCapabilityRequirement[];
+}
+export interface FortemiCapabilityDegradation {
+    requested: string;
+    selected?: string;
+    reason: "unsupported" | "version-insufficient" | "limit-insufficient";
+    changedGuarantees: string[];
+}
+export interface FortemiCapabilityDecision {
+    accepted: boolean;
+    selected: string[];
+    degradations: FortemiCapabilityDegradation[];
+    diagnostics: string[];
+}
+/** SemVer 2.0.0 precedence; build metadata is ignored. `null` means unparseable. */
+export declare function compareFortemiCapabilityVersions(left: unknown, right: unknown): number | null;
+/** Structural and semantic validation of an advertised capability descriptor. */
+export declare function validateFortemiCapabilityDescriptor(descriptor: unknown): string[];
+/** Structural and semantic validation of a negotiation request AIWG is about to send. */
+export declare function validateFortemiCapabilityRequest(request: unknown): string[];
+/**
+ * Pure negotiation of a request against an advertised descriptor. Performs no
+ * I/O and mutates neither input, so a caller can compare the result with the
+ * decision a server reports for the same pair.
+ */
+export declare function negotiateFortemiCapabilities(descriptor: unknown, request: unknown): FortemiCapabilityDecision;
+//# sourceMappingURL=fortemi-capability.d.ts.map