@aiwg/cli 2026.9.9 → 2026.9.10

package/bin/aiwg.mjs

@@ -166,11 +166,12 @@ const FAST_HELP_TEXT = `
   PROMOTE
     promote <name>               Graduate project-local bundle to upstream (--to upstream|corpus, --dry-run, --cleanup)
 
-  RALPH LOOP
-    ralph "<task>"               Execute iterative task loop (--completion, --max-iterations)
-    ralph-status                 Check current loop status
-    ralph-abort                  Abort running loop
-    ralph-resume                 Resume interrupted loop
+  AGENT LOOP
+    agent-loop "<task>"          Execute iterative task loop (--completion, --max-iterations)
+    agent-loop-status            Check current loop status
+    agent-loop-abort             Abort running loop
+    agent-loop-resume            Resume interrupted loop
+                                 (legacy ralph* names remain accepted as aliases)
 
   MAINTENANCE
     doctor                       Check installation health
@@ -382,6 +383,29 @@ async function applyVerbosityFromArgs(args, routerPath) {
   return level;
 }
 
+/**
+ * Commands that only read state and therefore stay available while the
+ * recorded installation identity disagrees with the executing checkout
+ * (#2559). Everything else fails closed until the operator adopts or
+ * switches the identity. `index` is limited to its inspection subcommands;
+ * `index build` rewrites the capability index and is treated as a write.
+ */
+const RECOVERY_SAFE_COMMANDS = new Set([
+  'version', 'status', 'doctor', 'runtime-info', 'discover', 'show', 'help',
+]);
+const RECOVERY_SAFE_INDEX_SUBCOMMANDS = new Set(['query', 'deps', 'stats']);
+
+function isRecoverySafeCommand(args) {
+  const command = args.find((arg) => !arg.startsWith('-'));
+  if (!command) return false;
+  if (RECOVERY_SAFE_COMMANDS.has(command)) return true;
+  if (command === 'index') {
+    const sub = args.slice(args.indexOf(command) + 1).find((arg) => !arg.startsWith('-'));
+    return sub !== undefined && RECOVERY_SAFE_INDEX_SUBCOMMANDS.has(sub);
+  }
+  return false;
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -423,11 +447,32 @@ async function main() {
     }
     const { assertCanonicalInstallation } = await import(pathToFileURL(identityPath).href);
     const readOnlyPreview = args.includes('--dry-run');
-    assertCanonicalInstallation({
-      actualRoot: activePackageRoot,
-      createIfMissing: !readOnlyPreview,
-      allowUnrecorded: readOnlyPreview,
-    });
+    try {
+      assertCanonicalInstallation({
+        actualRoot: activePackageRoot,
+        createIfMissing: !readOnlyPreview,
+        allowUnrecorded: readOnlyPreview,
+      });
+    } catch (error) {
+      if (error?.code !== 'AIWG_INSTALLATION_DRIFT' || !isRecoverySafeCommand(args)) throw error;
+      // Read-only diagnostics stay reachable under drift so the documented
+      // recovery ladder (status → doctor → runtime-info → version → local
+      // discover) can run before the identity is repaired. Every mutating
+      // command still fails closed above (#2559).
+      const drift = Array.isArray(error.status?.drift) ? error.status.drift : [];
+      process.env['AIWG_INSTALLATION_DRIFT'] = JSON.stringify({
+        state: error.status?.state ?? 'mismatch',
+        drift,
+      });
+      process.stderr.write(
+        `aiwg: warning: installation identity drift detected; \`${args[0]}\` is read-only and continues, ` +
+        'but update, refresh, and deployment stay blocked until the identity is repaired.\n' +
+        drift.map((item) => `- ${item}\n`).join('') +
+        'Inspect: aiwg installation show\n' +
+        'Adopt this installation: aiwg installation adopt\n' +
+        'Switch deliberately: aiwg installation switch --root <path> --method <npm|web|source> [--manager <absolute-path>]\n',
+      );
+    }
   }
 
   // Wire up the logger level from -v/-vv/--quiet/AIWG_LOG_LEVEL before any

package/dist/src/artifacts/cli.js

@@ -1374,6 +1374,10 @@ async function handleSetQuery(args) {
         backend,
     });
 }
+/** `index discover` flags that consume the following argument as a value. */
+const DISCOVER_VALUE_FLAGS = new Set([
+    '--type', '--limit', '--format', '--graph', '--backend', '--resource-source', '--aiwg-version',
+]);
 /**
  * Handle 'index discover' command — capability-search for AIWG operational
  * assets.
@@ -1391,17 +1395,25 @@ async function handleSetQuery(args) {
 async function handleDiscover(args) {
     const { discoverCapability } = await import('./query-engine.js');
     const cwd = process.cwd();
-    // Parse positional phrase (everything before flags)
+    // Parse the positional phrase. Flags may appear before or after it — the
+    // documented local-backend fallback is written flag-first
+    // (`aiwg discover --backend local "<phrase>"`, #2530), so a phrase after a
+    // value flag must not be swallowed as that flag's argument (#2559).
     const textParts = [];
     const flags = [];
-    let inFlags = false;
-    for (const arg of args) {
-        if (arg.startsWith('--'))
-            inFlags = true;
-        if (inFlags)
-            flags.push(arg);
-        else
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('--')) {
             textParts.push(arg);
+            continue;
+        }
+        flags.push(arg);
+        const bare = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg;
+        const next = args[index + 1];
+        if (DISCOVER_VALUE_FLAGS.has(bare) && !arg.includes('=') && next !== undefined && !next.startsWith('--')) {
+            flags.push(next);
+            index += 1;
+        }
     }
     const phrase = textParts.join(' ').trim();
     if (!phrase) {

package/dist/src/artifacts/corpus-views/taxonomies.js

@@ -110,7 +110,7 @@ export const PIPELINE_STAGES = [
     ['4. Mixture-of-Experts & Sparse Architectures', 'Sparsely activated models as a parallel pretraining strategy.', ['REF-007']],
     ['5. Instruction Tuning & SFT', 'Supervised fine-tuning on instructions to convert base models into assistants.', ['REF-055', 'REF-435', 'REF-470']],
     ['6. RLHF, DPO, and Preference Optimization', 'Aligning models with human and AI feedback.', ['REF-025', 'REF-055', 'REF-449']],
-    ['7. RLVR & Reasoning RL', 'Verifiable-reward RL for reasoning, math, and code.', ['REF-819', 'REF-957', 'REF-457']],
+    ['7. RLVR & Reasoning RL', 'Verifiable-reward RL for reasoning, math, and code.', ['REF-394', 'REF-957', 'REF-457']],
     ['8. PEFT / LoRA / Adapter-Based Adaptation', 'Parameter-efficient fine-tuning when full SFT is impractical.', ['REF-049']],
     ['9. Quantization, Pruning & Compression', 'Shrinking trained models for inference deployment.', ['REF-051']],
     ['10. Inference Serving & Optimization', 'Productionizing trained models: batching, KV cache, throughput.', ['REF-101', 'REF-102', 'REF-312', 'REF-313']],

package/dist/src/cli/handlers/help.js

@@ -134,11 +134,12 @@ function displayHelp() {
     helpGroup('PROMOTE', [
         ['promote <name>', 'Graduate project-local bundle to upstream (--to upstream|corpus, --dry-run, --cleanup)'],
     ]);
-    helpGroup('RALPH LOOP', [
-        ['ralph "<task>"', 'Execute iterative task loop (--completion, --max-iterations)'],
-        ['ralph-status', 'Check current loop status'],
-        ['ralph-abort', 'Abort running loop'],
-        ['ralph-resume', 'Resume interrupted loop'],
+    helpGroup('AGENT LOOP', [
+        ['agent-loop "<task>"', 'Execute iterative task loop (--completion, --max-iterations)'],
+        ['agent-loop-status', 'Check current loop status'],
+        ['agent-loop-abort', 'Abort running loop'],
+        ['agent-loop-resume', 'Resume interrupted loop'],
+        ['', 'Legacy ralph* names remain accepted as aliases'],
     ]);
     helpGroup('MAINTENANCE', [
         ['doctor', 'Check installation health'],

package/dist/src/cli/handlers/init.js

@@ -17,6 +17,7 @@ import readline from 'readline';
 import { readAiwgConfig, writeAiwgConfig, emptyConfig, populateDeployedTo, VALID_PROVIDERS, getConfigPath, } from '../../config/aiwg-config.js';
 import * as ui from '../ui.js';
 import { askString as sharedAskString, askYesNo as sharedAskYesNo } from '../prompt-utils.js';
+import { normalizeProviderDefinitionId } from '../../providers/provider-definitions.js';
 import { writeNormalizedAiwgMd } from '../../smiths/context-pipeline/finalization.js';
 import { ensureWorkspaceContext } from '../../smiths/context-pipeline/workspace-context.js';
 const PROVIDER_LABELS = {
@@ -61,9 +62,13 @@ async function askProviders(rl, signal) {
         const num = parseInt(part, 10);
         if (!isNaN(num) && num >= 1 && num <= VALID_PROVIDERS.length) {
             selected.push(VALID_PROVIDERS[num - 1]);
+            continue;
         }
-        else if (VALID_PROVIDERS.includes(part)) {
-            selected.push(part);
+        // Accept canonical ids and registered aliases (e.g. `dsh` for
+        // `deepseek-harness`) so the picker honours the same names as `--provider`.
+        const canonical = normalizeProviderDefinitionId(part);
+        if (canonical && VALID_PROVIDERS.includes(canonical)) {
+            selected.push(canonical);
         }
         else {
             ui.warn(`  Unknown provider '${part}' — skipped`);

package/dist/src/cli/handlers/ralph.js

@@ -156,7 +156,7 @@ export class RalphHandler {
     name = 'Agent Loop';
     description = 'Execute iterative task loop with automatic completion detection';
     category = 'ralph';
-    aliases = ['ralph', '-ralph', '--ralph'];
+    aliases = ['agent-loop', '--agent-loop', 'ralph', '-ralph', '--ralph'];
     async execute(ctx) {
         const parsed = parseRalphArgs(ctx.args);
         // Show help
@@ -334,7 +334,7 @@ export class RalphStatusHandler {
     name = 'Ralph Status';
     description = 'Show Agent loop status and iteration history';
     category = 'ralph';
-    aliases = ['ralph-status'];
+    aliases = ['agent-loop-status', 'ralph-status'];
     async execute(ctx) {
         const showAll = ctx.args.includes('--all') || ctx.args.includes('-a');
         const statuses = getLoopStatuses(process.cwd());
@@ -402,7 +402,7 @@ export class RalphAbortHandler {
     name = 'Ralph Abort';
     description = 'Abort currently running Agent loop';
     category = 'ralph';
-    aliases = ['ralph-abort'];
+    aliases = ['agent-loop-abort', 'ralph-abort'];
     async execute(ctx) {
         // Parse --loop-id if provided
         let loopId;
@@ -428,7 +428,7 @@ export class RalphResumeHandler {
     name = 'Ralph Resume';
     description = 'Resume previously aborted Agent loop';
     category = 'ralph';
-    aliases = ['ralph-resume'];
+    aliases = ['agent-loop-resume', 'ralph-resume'];
     async execute(ctx) {
         // Parse arguments
         let loopId;
@@ -493,7 +493,7 @@ export const ralphExternalHandler = {
     name: 'Agent Loop External',
     description: 'Crash-resilient external loop with state persistence and CI/CD integration',
     category: 'ralph',
-    aliases: ['ralph-external', '--ralph-external', '--agent-loop-ext'],
+    aliases: ['agent-loop-ext', '--agent-loop-ext', 'ralph-external', '--ralph-external'],
     async execute(ctx) {
         const runner = createScriptRunner(ctx.frameworkRoot);
         // Delegate to the external Ralph supervisor script
@@ -510,7 +510,7 @@ export const ralphMemoryHandler = {
     name: 'Ralph Memory',
     description: 'Manage Ralph semantic memory entries (list, query, clear)',
     category: 'ralph',
-    aliases: ['--ralph-memory'],
+    aliases: ['--agent-loop-memory', '--ralph-memory'],
     async execute(ctx) {
         const runner = createScriptRunner(ctx.frameworkRoot);
         return runner.run('tools/ralph-external/memory-manager.mjs', ['--cli', ...ctx.args]);
@@ -526,7 +526,7 @@ export const ralphConfigHandler = {
     name: 'Ralph Config',
     description: 'View and configure Agent loop settings (show, set, reset, preset)',
     category: 'ralph',
-    aliases: ['--ralph-config'],
+    aliases: ['--agent-loop-config', '--ralph-config'],
     async execute(ctx) {
         const runner = createScriptRunner(ctx.frameworkRoot);
         return runner.run('tools/ralph-external/orchestrator.mjs', ['--config', ...ctx.args]);
@@ -543,7 +543,7 @@ export class RalphAttachHandler {
     name = 'Ralph Attach';
     description = 'Attach to a running Agent loop\'s live output stream';
     category = 'ralph';
-    aliases = ['ralph-attach'];
+    aliases = ['agent-loop-attach', 'ralph-attach'];
     async execute(ctx) {
         let loopId;
         const loopIdIndex = ctx.args.indexOf('--loop-id');

package/dist/src/cli/handlers/steward.js

@@ -276,7 +276,15 @@ async function handleSteward(args, ctx) {
                 return;
             }
             const diagnostics = await auditLegacyPermissions(projectDir, config);
-            console.log(`  ${dryRun ? 'Would normalize' : 'Normalizing'} ${diagnostics.filter(d => d.code.startsWith('legacy-')).length} legacy permission source(s).`);
+            const legacyCount = diagnostics.filter(d => d.code.startsWith('legacy-')).length;
+            if (legacyCount === 0 && !config.authorization) {
+                // Nothing legacy to convert: the only work is writing the initial
+                // default-deny block, which is what clears doctor's warning (#2563).
+                console.log(`  ${dryRun ? 'Would write' : 'Writing'} an initial default-deny authorization block (no legacy permission sources found).`);
+            }
+            else {
+                console.log(`  ${dryRun ? 'Would normalize' : 'Normalizing'} ${legacyCount} legacy permission source(s).`);
+            }
             console.log(`  Result: ${Object.keys(normalized.authorization?.permissions ?? {}).length} permissions, ${Object.keys(normalized.authorization?.roles ?? {}).length} roles, ${normalized.authorization?.assignments.length ?? 0} assignments; default deny.`);
             if (apply) {
                 const backup = await backupConfig(projectDir);

package/dist/src/cli/handlers/use.js

@@ -1256,6 +1256,10 @@ async function deployOneProjectLocalBundle(opts) {
             // never reach <provider>/.aiwg/skills/, leaving them invisible to
             // both the platform and the index.
             '--copy-all',
+            // That copy-all is the deployer's doing, not the operator's, so the
+            // provider's startup listing cap still applies; overflow lands on the
+            // standard tier instead of over the cap (#2561).
+            '--listing-budget',
             // Provenance for the managed marker (#2502). Without this the deployer
             // stamps `bundled`/`unknown`, and `aiwg refresh`'s stale-artifact prune —
             // whose desired set is the packaged framework corpus — deletes every

package/dist/src/cli/handlers/version.js

@@ -36,11 +36,20 @@ export const versionHandler = {
  * describing, and names the command that explains the rest (#2529).
  */
 function printDrift(fp) {
-    if (!fp.drift)
+    if (fp.drift) {
+        const method = fp.installation?.identity?.method ?? 'unrecorded';
+        const declared = fp.drift.canonicalVersion ? ` (${fp.drift.canonicalVersion})` : '';
+        ui.dim(`    ! canonical install declares ${method} at ${fp.drift.canonicalRoot}${declared} — run \`aiwg installation show\``);
         return;
-    const method = fp.installation?.identity?.method ?? 'unrecorded';
-    const declared = fp.drift.canonicalVersion ? ` (${fp.drift.canonicalVersion})` : '';
-    ui.dim(`    ! canonical install declares ${method} at ${fp.drift.canonicalRoot}${declared} — run \`aiwg installation show\``);
+    }
+    // Same root, different method (a source checkout recorded as npm, or the
+    // reverse) is drift too; `version` is the first recovery command an operator
+    // reaches for, so it must say so instead of looking aligned (#2559).
+    const state = fp.installation?.state;
+    if (state && state !== 'aligned' && state !== 'unrecorded') {
+        const reasons = Array.isArray(fp.installation?.drift) ? fp.installation.drift : [];
+        ui.dim(`    ! installation identity ${state}: ${reasons.join('; ') || 'see aiwg installation show'} — run \`aiwg installation show\``);
+    }
 }
 function collectFingerprint(versionInfo) {
     const loggerInfo = getLoggerInfo();

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

@@ -3,6 +3,8 @@ 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';
@@ -379,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'
@@ -645,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
@@ -656,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')),

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/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