@open-agent-toolkit/cli 0.2.63 → 0.2.64

package/dist/commands/tools/shared/pack-evidence.d.ts

@@ -1,3 +1,4 @@
+import type { ManagedContentKind, ProviderActivationSource, ProviderCapabilitySupport, ProviderProjectionMode } from '../../../providers/shared/registry.js';
 import type { ConcreteScope } from '../../../shared/types.js';
 import type { PackInventory, ScopedPackInventory } from './pack-inventory.js';
 import type { PackCompleteness, PackName } from './types.js';
@@ -33,12 +34,69 @@ export interface PackEvidenceDiagnostic {
     detail: string;
     recovery: readonly RecoveryAction[];
 }
+/**
+ * Provider diagnostic codes and their pinned severities.
+ *
+ * `packEvidenceBlock` and the lifecycle-outcome status derive from the
+ * severity, never from the code name, so adding a code later cannot silently
+ * change a pack evidence block status or an install exit code.
+ */
+export declare const PROVIDER_DIAGNOSTIC_SEVERITY: {
+    readonly 'provider-inactive': 'info';
+    readonly 'provider-unsupported': 'info';
+    readonly 'provider-materialization-missing': 'warning';
+    readonly 'provider-materialization-failed': 'error';
+    readonly 'visibility-unknown': 'info';
+    readonly 'refresh-required': 'info';
+    readonly 'restart-required': 'info';
+};
+export type ProviderDiagnosticCode = keyof typeof PROVIDER_DIAGNOSTIC_SEVERITY;
+/**
+ * Marks a diagnostic as projected from provider reachability evidence.
+ *
+ * Consumers that re-project an evidence item use this to replace the previous
+ * provider rows without disturbing canonical or inventory-derived diagnostics.
+ */
+export declare const PROVIDER_DIAGNOSTIC_SOURCE = "provider-registry";
+export type ProviderProjectionState = 'projected' | 'absent' | 'not-applicable';
+export type ProviderMaterializationState = 'materialized' | 'missing' | 'failed' | 'not-applicable';
+export type ProviderVisibilityState = 'live' | 'manual-refresh' | 'restart-required' | 'unknown'
+/** The row is inactive or unsupported, so catalog visibility is moot. */
+ | 'not-applicable';
+/**
+ * Per provider, scope, and content kind reachability, derived from the
+ * config-aware provider registry the sync engine uses. Every field is
+ * required: a permissive interface is what let every production path emit
+ * `providers: []` while still type-checking.
+ */
 export interface ProviderReachabilityEvidence {
     provider: string;
     scope: ConcreteScope;
-    contentKind: 'skill' | 'agent' | 'rule' | 'directory';
+    contentKind: ManagedContentKind;
     assets: readonly string[];
-    [key: string]: unknown;
+    activation: {
+        state: 'active' | 'inactive';
+        source: ProviderActivationSource;
+        reason: string;
+    };
+    capability: {
+        support: ProviderCapabilitySupport;
+        projectionModes: readonly ProviderProjectionMode[];
+        reason: string;
+    };
+    projection: {
+        state: ProviderProjectionState;
+        mode: ProviderProjectionMode | null;
+    };
+    materialization: {
+        state: ProviderMaterializationState;
+        detail: string;
+    };
+    visibility: {
+        state: ProviderVisibilityState;
+        reason: string;
+    };
+    recovery: readonly RecoveryAction[];
 }
 export interface ToolPackEvidence {
     schemaVersion: 1;
@@ -58,9 +116,27 @@ export declare function unavailablePackScopeFacts(input: {
     reason: string;
 }): PackScopeFacts;
 export declare function hasScopedPackRealizationEvidence(inventory: ScopedPackInventory): boolean;
+/**
+ * Emits the pinned severity-matrix diagnostics for provider reachability.
+ *
+ * `mode` is load-bearing rather than cosmetic: a read-only inventory surface
+ * (`list`, `info`, `status`, `doctor`) ran no sync, so it can never have
+ * observed a materialization failure. Emitting `provider-materialization-failed`
+ * there would report an error severity from evidence that does not exist.
+ */
+export declare function providerDiagnostics(input: {
+    pack: PackName;
+    providers: readonly ProviderReachabilityEvidence[];
+    mode: 'lifecycle' | 'inventory';
+}): PackEvidenceDiagnostic[];
 export declare function projectPackEvidence(input: {
     canonical: PackInventory | null;
     scopes: readonly PackScopeFacts[];
     providers?: readonly ProviderReachabilityEvidence[];
+    /**
+     * Defaults to the conservative read-only reading. A surface that actually
+     * ran a sync opts in to `lifecycle` so an observed failure can be reported.
+     */
+    providerMode?: 'lifecycle' | 'inventory';
 }): ToolPackEvidence;
 //# sourceMappingURL=pack-evidence.d.ts.map

package/dist/commands/tools/shared/pack-evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack-evidence.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-evidence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pack-evidence.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-evidence.ts"],"names":[],"mappings":"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"}

package/dist/commands/tools/shared/pack-evidence.js

@@ -1,3 +1,26 @@
+/**
+ * Provider diagnostic codes and their pinned severities.
+ *
+ * `packEvidenceBlock` and the lifecycle-outcome status derive from the
+ * severity, never from the code name, so adding a code later cannot silently
+ * change a pack evidence block status or an install exit code.
+ */
+export const PROVIDER_DIAGNOSTIC_SEVERITY = {
+    'provider-inactive': 'info',
+    'provider-unsupported': 'info',
+    'provider-materialization-missing': 'warning',
+    'provider-materialization-failed': 'error',
+    'visibility-unknown': 'info',
+    'refresh-required': 'info',
+    'restart-required': 'info',
+};
+/**
+ * Marks a diagnostic as projected from provider reachability evidence.
+ *
+ * Consumers that re-project an evidence item use this to replace the previous
+ * provider rows without disturbing canonical or inventory-derived diagnostics.
+ */
+export const PROVIDER_DIAGNOSTIC_SOURCE = 'provider-registry';
 function healthForStatuses(statuses) {
     const present = statuses.filter((status) => status !== 'missing');
     if (present.length === 0)
@@ -108,12 +131,76 @@ function canonicalDiagnostics(pack, scopes) {
     }
     return diagnostics;
 }
+function providerDiagnostic(pack, evidence, code, detail) {
+    return {
+        code,
+        severity: PROVIDER_DIAGNOSTIC_SEVERITY[code],
+        pack,
+        scope: evidence.scope,
+        provider: evidence.provider,
+        contentKind: evidence.contentKind,
+        affectedAssets: evidence.assets,
+        source: PROVIDER_DIAGNOSTIC_SOURCE,
+        detail,
+        recovery: evidence.recovery,
+    };
+}
+/**
+ * Emits the pinned severity-matrix diagnostics for provider reachability.
+ *
+ * `mode` is load-bearing rather than cosmetic: a read-only inventory surface
+ * (`list`, `info`, `status`, `doctor`) ran no sync, so it can never have
+ * observed a materialization failure. Emitting `provider-materialization-failed`
+ * there would report an error severity from evidence that does not exist.
+ */
+export function providerDiagnostics(input) {
+    const diagnostics = [];
+    for (const evidence of input.providers) {
+        if (evidence.activation.state === 'inactive') {
+            // Only an explicitly disabled provider is reportable. A provider that
+            // was never detected and never configured is not a finding about this
+            // pack: emitting one per registered provider, per content kind, per
+            // pack would bury the actionable rows under inventory noise. The
+            // inactive state itself is still carried on the evidence row.
+            if (evidence.activation.source === 'config-disabled') {
+                diagnostics.push(providerDiagnostic(input.pack, evidence, 'provider-inactive', `${evidence.provider} is not active for ${evidence.scope} scope: ${evidence.activation.reason}`));
+            }
+            continue;
+        }
+        if (evidence.capability.support !== 'supported') {
+            diagnostics.push(providerDiagnostic(input.pack, evidence, 'provider-unsupported', evidence.capability.reason));
+            continue;
+        }
+        if (evidence.materialization.state === 'failed') {
+            if (input.mode === 'lifecycle') {
+                diagnostics.push(providerDiagnostic(input.pack, evidence, 'provider-materialization-failed', evidence.materialization.detail));
+            }
+            continue;
+        }
+        if (evidence.materialization.state === 'missing') {
+            diagnostics.push(providerDiagnostic(input.pack, evidence, 'provider-materialization-missing', evidence.materialization.detail));
+        }
+        if (evidence.projection.state !== 'projected')
+            continue;
+        if (evidence.visibility.state === 'unknown') {
+            diagnostics.push(providerDiagnostic(input.pack, evidence, 'visibility-unknown', evidence.visibility.reason));
+        }
+        else if (evidence.visibility.state === 'manual-refresh') {
+            diagnostics.push(providerDiagnostic(input.pack, evidence, 'refresh-required', evidence.visibility.reason));
+        }
+        else if (evidence.visibility.state === 'restart-required') {
+            diagnostics.push(providerDiagnostic(input.pack, evidence, 'restart-required', evidence.visibility.reason));
+        }
+    }
+    return diagnostics;
+}
 export function projectPackEvidence(input) {
     const pack = input.canonical?.pack ??
         input.scopes[0]?.intent.pack ??
         (() => {
             throw new Error('Pack evidence requires canonical inventory or scope facts');
         })();
+    const providers = input.providers ?? [];
     return {
         schemaVersion: 1,
         pack,
@@ -126,7 +213,14 @@ export function projectPackEvidence(input) {
             .filter(({ realization }) => realization === 'unknown')
             .map(({ scope }) => scope),
         realizedPlacement: placementForScopes(input.scopes),
-        providers: input.providers ?? [],
-        diagnostics: canonicalDiagnostics(pack, input.scopes),
+        providers,
+        diagnostics: [
+            ...canonicalDiagnostics(pack, input.scopes),
+            ...providerDiagnostics({
+                pack,
+                providers,
+                mode: input.providerMode ?? 'inventory',
+            }),
+        ],
     };
 }

package/dist/commands/tools/shared/pack-lifecycle-outcome.d.ts

@@ -33,7 +33,18 @@ export declare function resolveAdditivePackScopeSelection(input: {
     knownRealizedScopes: readonly ConcreteScope[];
     unknownScopes: readonly ConcreteScope[];
 }): PackScopeSelection;
+/**
+ * Derives the provider sync outcome from an auto-sync run and its evidence.
+ *
+ * Status follows the pinned severity matrix rather than the diagnostic code
+ * name: only an observed `failed` materialization degrades an otherwise
+ * successful run to `partial`. An inactive provider, an unsupported content
+ * kind, or a host that needs a catalog refresh are `info`-severity facts and
+ * leave the outcome `complete`, so a healthy install keeps exit code 0.
+ */
 export declare function providerSyncOutcomeFromAutoSync(result: AutoSyncResult, providers?: readonly ProviderReachabilityEvidence[]): ProviderSyncOutcome;
+/** A `not-run` sync outcome that still carries registry-derived evidence. */
+export declare function notRunProviderSyncOutcome(providers?: readonly ProviderReachabilityEvidence[], reason?: string): ProviderSyncOutcome;
 export declare function evaluatePackLifecycleOutcome(input: {
     selection: PackScopeSelection;
     lifecycle: readonly PackLifecycleResult[];

package/dist/commands/tools/shared/pack-lifecycle-outcome.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack-lifecycle-outcome.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-lifecycle-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC;IAClC,sBAAsB,EAAE,SAAS,aAAa,EAAE,CAAC;IACjD,YAAY,EAAE,SAAS,aAAa,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtD,SAAS,EAAE,SAAS,4BAA4B,EAAE,CAAC;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,CAAC,CAAC;IACjB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE;QACT,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,qBAAqB,CAAC;QACnE,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;KACzC,CAAC;IACF,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC1C,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CACrC;AASD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE;IACvD,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC;IAClC,mBAAmB,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,aAAa,EAAE,SAAS,aAAa,EAAE,CAAC;CACzC,GAAG,kBAAkB,CAkBrB;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,SAAS,GAAE,SAAS,4BAA4B,EAAO,GACtD,mBAAmB,CAYrB;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,oBAAoB,CAqEvB"}
+{"version":3,"file":"pack-lifecycle-outcome.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-lifecycle-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC;IAClC,sBAAsB,EAAE,SAAS,aAAa,EAAE,CAAC;IACjD,YAAY,EAAE,SAAS,aAAa,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtD,SAAS,EAAE,SAAS,4BAA4B,EAAE,CAAC;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,CAAC,CAAC;IACjB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE;QACT,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,qBAAqB,CAAC;QACnE,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;KACzC,CAAC;IACF,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC1C,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CACrC;AASD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE;IACvD,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC;IAClC,mBAAmB,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,aAAa,EAAE,SAAS,aAAa,EAAE,CAAC;CACzC,GAAG,kBAAkB,CAkBrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,SAAS,GAAE,SAAS,4BAA4B,EAAO,GACtD,mBAAmB,CAiBrB;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CACvC,SAAS,GAAE,SAAS,4BAA4B,EAAO,EACvD,MAAM,CAAC,EAAE,MAAM,GACd,mBAAmB,CAOrB;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,oBAAoB,CAqEvB"}

package/dist/commands/tools/shared/pack-lifecycle-outcome.js

@@ -20,18 +20,39 @@ export function resolveAdditivePackScopeSelection(input) {
         ]),
     };
 }
+/**
+ * Derives the provider sync outcome from an auto-sync run and its evidence.
+ *
+ * Status follows the pinned severity matrix rather than the diagnostic code
+ * name: only an observed `failed` materialization degrades an otherwise
+ * successful run to `partial`. An inactive provider, an unsupported content
+ * kind, or a host that needs a catalog refresh are `info`-severity facts and
+ * leave the outcome `complete`, so a healthy install keeps exit code 0.
+ */
 export function providerSyncOutcomeFromAutoSync(result, providers = []) {
+    const materializationFailed = providers.some(({ materialization }) => materialization.state === 'failed');
     return {
         scopes: result.scopes,
         status: result.scopes.length === 0
             ? 'not-run'
-            : result.synced
-                ? 'complete'
-                : 'failed',
+            : !result.synced
+                ? 'failed'
+                : materializationFailed
+                    ? 'partial'
+                    : 'complete',
         providers,
         ...(result.error ? { error: result.error } : {}),
     };
 }
+/** A `not-run` sync outcome that still carries registry-derived evidence. */
+export function notRunProviderSyncOutcome(providers = [], reason) {
+    return {
+        scopes: [],
+        status: 'not-run',
+        providers,
+        ...(reason ? { error: reason } : {}),
+    };
+}
 export function evaluatePackLifecycleOutcome(input) {
     const recovery = [];
     let canonicalStatus;

package/dist/commands/tools/shared/pack-provider-evidence.d.ts

@@ -0,0 +1,73 @@
+import type { ManagedContentKind, ProviderScopeContext, UserAgentMaterializationCoverage } from '../../../providers/shared/registry.js';
+import type { ConcreteScope } from '../../../shared/types.js';
+import type { AutoSyncResult } from './auto-sync.js';
+import { type ProviderReachabilityEvidence, type ToolPackEvidence } from './pack-evidence.js';
+import type { PackInventory, ScopedPackInventory } from './pack-inventory.js';
+import { type ProviderExtensionOperationEvidence, type ProviderSyncOperationEvidence, type ProviderRefreshPolicyLookup } from './provider-reachability.js';
+import type { PackName } from './types.js';
+type AssetsByContentKind = Partial<Record<ManagedContentKind, readonly string[]>>;
+/** Realized managed assets for one scope, grouped by provider content kind. */
+export declare function packAssetsByContentKind(scoped: ScopedPackInventory): AssetsByContentKind;
+/**
+ * Assets the pack inventory reports as having no provider materialization.
+ *
+ * This is an inventory observation about assets, not a reachability claim:
+ * the mapper still decides which providers are responsible from registry
+ * capability alone.
+ */
+export declare function unmaterializedAssetsByContentKind(scoped: ScopedPackInventory): AssetsByContentKind;
+export interface PackProviderEvidenceInput {
+    pack: PackName;
+    /** Per-scope pack inventory; the sole source of the asset lists. */
+    scopedInventories: readonly ScopedPackInventory[];
+    providerContexts: readonly ProviderScopeContext[];
+    mode: 'lifecycle' | 'inventory';
+    /** Only meaningful in `lifecycle` mode; `false` records a skipped sync. */
+    syncRan?: boolean;
+    syncOperationResults?: readonly ProviderSyncOperationEvidence[];
+    extensionResults?: readonly ProviderExtensionOperationEvidence[];
+    refreshPolicy?: ProviderRefreshPolicyLookup;
+    /** Restricts evidence to these scopes; defaults to every resolved context. */
+    scopes?: readonly ConcreteScope[];
+}
+/**
+ * The single seam that turns provider registry state plus pack inventory into
+ * reachability evidence, shared by the lifecycle outcomes and every inventory
+ * renderer so the two cannot drift.
+ */
+export declare function packProviderEvidence(input: PackProviderEvidenceInput): ProviderReachabilityEvidence[];
+/**
+ * Drops `user-agent-unmaterialized` when an active provider materializes all
+ * managed user-scope roles.
+ *
+ * `status` and `doctor` have always applied this; `list` and `info` did not,
+ * so they reported user agents as unmaterialized that the active Codex or
+ * Cursor adapter in fact supplies. Sharing one implementation is what makes
+ * the four surfaces agree.
+ */
+export declare function applyUserAgentCoverage(inventory: PackInventory, coverage: UserAgentMaterializationCoverage): PackInventory;
+/**
+ * Provider evidence for a pack lifecycle outcome (install, update, remove).
+ *
+ * When `sync` is absent the auto-sync step did not run, so no projection or
+ * materialization claim is made and the evidence carries activation and
+ * capability only — the pinned matrix's `not-run` row.
+ */
+export declare function lifecycleProviderEvidence(input: {
+    pack: PackName;
+    scopedInventories: readonly ScopedPackInventory[];
+    providerContexts: readonly ProviderScopeContext[];
+    scopes?: readonly ConcreteScope[];
+    sync?: AutoSyncResult;
+}): ProviderReachabilityEvidence[];
+/**
+ * Re-projects a pack evidence item with lifecycle provider evidence.
+ *
+ * `providerDiagnostics` only emits `provider-materialization-failed` in
+ * lifecycle mode, so an observed failure reaches pack evidence only when the
+ * outcome's `finalEvidence` is rebuilt with the run's provider rows. Without
+ * this the error-severity code would have no production emitter at all.
+ */
+export declare function withLifecycleProviderEvidence(evidence: ToolPackEvidence | null, providers: readonly ProviderReachabilityEvidence[]): ToolPackEvidence | null;
+export {};
+//# sourceMappingURL=pack-provider-evidence.d.ts.map

package/dist/commands/tools/shared/pack-provider-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-provider-evidence.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-provider-evidence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,gCAAgC,EACjC,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAGL,KAAK,4BAA4B,EACjC,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EAEL,KAAK,kCAAkC,EACvC,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EACjC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAiB,QAAQ,EAAE,MAAM,SAAS,CAAC;AAiBvD,KAAK,mBAAmB,GAAG,OAAO,CAChC,MAAM,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC,CAC9C,CAAC;AAUF,+EAA+E;AAC/E,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAUrB;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAOrB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,oEAAoE;IACpE,iBAAiB,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAClD,gBAAgB,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAClD,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;IAChC,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAChE,gBAAgB,CAAC,EAAE,SAAS,kCAAkC,EAAE,CAAC;IACjE,aAAa,CAAC,EAAE,2BAA2B,CAAC;IAC5C,8EAA8E;IAC9E,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,yBAAyB,GAC/B,4BAA4B,EAAE,CA4BhC;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,gCAAgC,GACzC,aAAa,CAkBf;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,iBAAiB,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAClD,gBAAgB,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAClD,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAClC,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,GAAG,4BAA4B,EAAE,CAiBjC;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,gBAAgB,GAAG,IAAI,EACjC,SAAS,EAAE,SAAS,4BAA4B,EAAE,GACjD,gBAAgB,GAAG,IAAI,CA2BzB"}

package/dist/commands/tools/shared/pack-provider-evidence.js

@@ -0,0 +1,161 @@
+import { PROVIDER_DIAGNOSTIC_SOURCE, providerDiagnostics, } from './pack-evidence.js';
+import { projectProviderReachability, } from './provider-reachability.js';
+import { refreshPolicyFromAdvice } from './sync-evidence.js';
+/**
+ * Pack asset kinds that a provider can project.
+ *
+ * `template`, `script`, and `seed` assets are canonical-only: no provider
+ * mapping or materialization extension consumes them, so claiming provider
+ * reachability for them would invent a surface that does not exist.
+ */
+const PROVIDER_CONTENT_KIND = {
+    skill: 'skill',
+    agent: 'agent',
+    directory: 'directory',
+};
+function pushAsset(target, contentKind, path) {
+    (target[contentKind] ??= []).push(path);
+}
+/** Realized managed assets for one scope, grouped by provider content kind. */
+export function packAssetsByContentKind(scoped) {
+    const grouped = {};
+    for (const asset of scoped.assets) {
+        if (asset.status === 'missing')
+            continue;
+        if (asset.definition.ownership[scoped.scope] !== 'managed')
+            continue;
+        const contentKind = PROVIDER_CONTENT_KIND[asset.definition.kind];
+        if (contentKind === undefined)
+            continue;
+        pushAsset(grouped, contentKind, asset.path);
+    }
+    return grouped;
+}
+/**
+ * Assets the pack inventory reports as having no provider materialization.
+ *
+ * This is an inventory observation about assets, not a reachability claim:
+ * the mapper still decides which providers are responsible from registry
+ * capability alone.
+ */
+export function unmaterializedAssetsByContentKind(scoped) {
+    const grouped = {};
+    for (const diagnostic of scoped.diagnostics) {
+        if (diagnostic.code !== 'user-agent-unmaterialized')
+            continue;
+        for (const path of diagnostic.paths)
+            pushAsset(grouped, 'agent', path);
+    }
+    return grouped;
+}
+/**
+ * The single seam that turns provider registry state plus pack inventory into
+ * reachability evidence, shared by the lifecycle outcomes and every inventory
+ * renderer so the two cannot drift.
+ */
+export function packProviderEvidence(input) {
+    const contexts = input.scopes
+        ? input.providerContexts.filter((context) => input.scopes.includes(context.scope))
+        : input.providerContexts;
+    return contexts.flatMap((providerScopeContext) => {
+        const scoped = input.scopedInventories.find(({ scope }) => scope === providerScopeContext.scope);
+        if (scoped === undefined)
+            return [];
+        const assets = packAssetsByContentKind(scoped);
+        if (Object.keys(assets).length === 0)
+            return [];
+        return projectProviderReachability({
+            providerScopeContext,
+            assets,
+            mode: input.mode,
+            ...(input.syncRan !== undefined ? { syncRan: input.syncRan } : {}),
+            ...(input.syncOperationResults
+                ? { syncOperationResults: input.syncOperationResults }
+                : {}),
+            ...(input.extensionResults
+                ? { extensionResults: input.extensionResults }
+                : {}),
+            ...(input.refreshPolicy ? { refreshPolicy: input.refreshPolicy } : {}),
+            unmaterializedAssets: unmaterializedAssetsByContentKind(scoped),
+        });
+    });
+}
+/**
+ * Drops `user-agent-unmaterialized` when an active provider materializes all
+ * managed user-scope roles.
+ *
+ * `status` and `doctor` have always applied this; `list` and `info` did not,
+ * so they reported user agents as unmaterialized that the active Codex or
+ * Cursor adapter in fact supplies. Sharing one implementation is what makes
+ * the four surfaces agree.
+ */
+export function applyUserAgentCoverage(inventory, coverage) {
+    if (coverage !== 'all')
+        return inventory;
+    return {
+        ...inventory,
+        scopes: inventory.scopes.map((scoped) => scoped.scope === 'user'
+            ? {
+                ...scoped,
+                diagnostics: scoped.diagnostics.filter(({ code }) => code !== 'user-agent-unmaterialized'),
+            }
+            : scoped),
+        diagnostics: inventory.diagnostics.filter(({ code }) => code !== 'user-agent-unmaterialized'),
+    };
+}
+/**
+ * Provider evidence for a pack lifecycle outcome (install, update, remove).
+ *
+ * When `sync` is absent the auto-sync step did not run, so no projection or
+ * materialization claim is made and the evidence carries activation and
+ * capability only — the pinned matrix's `not-run` row.
+ */
+export function lifecycleProviderEvidence(input) {
+    const runs = input.sync?.evidence ?? [];
+    return packProviderEvidence({
+        pack: input.pack,
+        scopedInventories: input.scopedInventories,
+        providerContexts: input.providerContexts,
+        mode: 'lifecycle',
+        syncRan: runs.some(({ ran }) => ran),
+        syncOperationResults: runs.flatMap(({ operationResults }) => operationResults),
+        extensionResults: runs.flatMap(({ extensionResults }) => extensionResults),
+        refreshPolicy: refreshPolicyFromAdvice(runs.flatMap(({ refreshAdvice }) => refreshAdvice)),
+        ...(input.scopes ? { scopes: input.scopes } : {}),
+    });
+}
+/**
+ * Re-projects a pack evidence item with lifecycle provider evidence.
+ *
+ * `providerDiagnostics` only emits `provider-materialization-failed` in
+ * lifecycle mode, so an observed failure reaches pack evidence only when the
+ * outcome's `finalEvidence` is rebuilt with the run's provider rows. Without
+ * this the error-severity code would have no production emitter at all.
+ */
+export function withLifecycleProviderEvidence(evidence, providers) {
+    if (evidence === null || providers.length === 0)
+        return evidence;
+    // Diagnostics are merged onto the existing item rather than re-derived
+    // through `projectPackEvidence`: that helper re-resolves the pack name from
+    // canonical inventory or scope facts and throws when neither is present,
+    // which must never happen inside a lifecycle path that already succeeded.
+    // Every already-computed field, including scope verification, is preserved.
+    return {
+        ...evidence,
+        providers,
+        diagnostics: [
+            // Previously projected provider rows are replaced, not appended to. The
+            // update and removal flows project once before auto-sync and again
+            // afterwards, so appending would emit each inactive or unsupported
+            // provider twice in the final JSON. Canonical diagnostics and the
+            // unattributed inventory-derived warning use a different `source` and
+            // are preserved.
+            ...evidence.diagnostics.filter(({ source }) => source !== PROVIDER_DIAGNOSTIC_SOURCE),
+            ...providerDiagnostics({
+                pack: evidence.pack,
+                providers,
+                mode: 'lifecycle',
+            }),
+        ],
+    };
+}

package/dist/commands/tools/shared/provider-context.d.ts

@@ -0,0 +1,88 @@
+import type { SyncConfig } from '../../../config/sync-config.js';
+import { type ProviderScopeContext, type UserAgentMaterializationCoverage } from '../../../providers/shared/registry.js';
+import type { ConcreteScope } from '../../../shared/types.js';
+export interface ProviderContextDependencies {
+    loadSyncConfig?: (configPath: string) => Promise<SyncConfig>;
+    resolveProviderScopeContext?: (input: {
+        scope: ConcreteScope;
+        scopeRoot: string;
+        config: SyncConfig;
+    }) => Promise<ProviderScopeContext>;
+}
+/**
+ * Outcome of one scope's provider-context resolution.
+ *
+ * A caller that only needs the context can keep using
+ * {@link resolveScopeProviderContext}, which collapses `failed` to `null`.
+ * A diagnostic that exists to explain why a provider view is missing needs the
+ * failure itself: silently dropping the scope tells that user "no providers
+ * configured" when the truth is "your sync config could not be read".
+ *
+ * There is no separate `absent` case on purpose. `loadSyncConfig` answers
+ * `ENOENT` with the defaults rather than throwing, so an absent config
+ * resolves normally and only a config that is present-but-unreadable — invalid
+ * JSON, schema-invalid, `EACCES`, a directory — reaches `failed`.
+ */
+export type ScopeProviderContextOutcome = {
+    status: 'resolved';
+    context: ProviderScopeContext;
+} | {
+    status: 'failed';
+    error: unknown;
+};
+/**
+ * Resolves the config-aware provider context for one scope, keeping the
+ * failure.
+ *
+ * Never throws: provider reachability is additive evidence on a lifecycle or
+ * inventory result, so a sync config that cannot be read must not fail an
+ * install that already succeeded. The error is returned instead of swallowed so
+ * a caller that can report it honestly is able to.
+ */
+export declare function resolveScopeProviderContextOutcome(input: {
+    scope: ConcreteScope;
+    scopeRoot: string;
+    dependencies?: ProviderContextDependencies;
+}): Promise<ScopeProviderContextOutcome>;
+/**
+ * Resolves the config-aware provider context for one scope.
+ *
+ * Returns `null` rather than throwing: provider reachability is additive
+ * evidence on a lifecycle or inventory result, so a missing or unreadable
+ * sync config must degrade to "no provider evidence" instead of failing an
+ * install that already succeeded. Callers that need to tell a failure apart
+ * from a legitimately empty result use
+ * {@link resolveScopeProviderContextOutcome} instead.
+ */
+export declare function resolveScopeProviderContext(input: {
+    scope: ConcreteScope;
+    scopeRoot: string;
+    dependencies?: ProviderContextDependencies;
+}): Promise<ProviderScopeContext | null>;
+/** Resolves provider contexts for every scope with a known root. */
+export declare function resolveProviderScopeContexts(input: {
+    scopeRoots: Readonly<Partial<Record<ConcreteScope, string>>>;
+    dependencies?: ProviderContextDependencies;
+}): Promise<ProviderScopeContext[]>;
+export interface PackProviderSurface {
+    contexts: ProviderScopeContext[];
+    /**
+     * Whether an active provider supplies managed user-scope agent roles.
+     * Derived from registry capability and sync config only, never from the
+     * presence of a provider directory.
+     */
+    userAgentCoverage: UserAgentMaterializationCoverage;
+}
+/**
+ * Resolves the provider surface every pack inventory renderer needs.
+ *
+ * `list`, `info`, `status`, and `doctor` all report the same packs, so they
+ * must agree on whether user-scope managed roles are materialized. Sharing
+ * this resolution is what keeps `list`/`info` from reporting unmaterialized
+ * user agents that `status`/`doctor` correctly suppress.
+ */
+export declare function resolvePackProviderSurface(input: {
+    scopeRoots: Readonly<Partial<Record<ConcreteScope, string>>>;
+    dependencies?: ProviderContextDependencies;
+}): Promise<PackProviderSurface>;
+//# sourceMappingURL=provider-context.d.ts.map

package/dist/commands/tools/shared/provider-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-context.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/provider-context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACtC,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,WAAW,2BAA2B;IAC1C,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7D,2BAA2B,CAAC,EAAE,CAAC,KAAK,EAAE;QACpC,KAAK,EAAE,aAAa,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,UAAU,CAAC;KACpB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACrC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,2BAA2B,GACnC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzC;;;;;;;;GAQG;AACH,wBAAsB,kCAAkC,CAAC,KAAK,EAAE;IAC9D,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,2BAA2B,CAAC;CAC5C,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAsBvC;AAED;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,CAAC,KAAK,EAAE;IACvD,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,2BAA2B,CAAC;CAC5C,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAGvC;AAED,oEAAoE;AACpE,wBAAsB,4BAA4B,CAAC,KAAK,EAAE;IACxD,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7D,YAAY,CAAC,EAAE,2BAA2B,CAAC;CAC5C,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAgBlC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,oBAAoB,EAAE,CAAC;IACjC;;;;OAIG;IACH,iBAAiB,EAAE,gCAAgC,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,KAAK,EAAE;IACtD,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7D,YAAY,CAAC,EAAE,2BAA2B,CAAC;CAC5C,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAY/B"}