@open-agent-toolkit/cli 0.2.63 → 0.2.64

package/dist/commands/tools/list/list-tools.js

@@ -2,6 +2,8 @@ import { resolveConcreteScopes } from '../../shared/shared.utils.js';
 import { formatPackEvidenceDetails, formatPackInventoryDetails, packEvidenceBlock, projectRenderablePackEvidence, unavailablePackEvidence, } from '../../tools/shared/format-pack-inventory.js';
 import { inventoryPack, } from '../../tools/shared/pack-inventory.js';
 import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
+import { applyUserAgentCoverage } from '../../tools/shared/pack-provider-evidence.js';
+import { resolvePackProviderSurface, } from '../../tools/shared/provider-context.js';
 export async function runListTools(context, dependencies) {
     const { logger } = context;
     const scopes = resolveConcreteScopes(context.scope);
@@ -23,15 +25,32 @@ export async function runListTools(context, dependencies) {
         userRoot: roots.user,
     };
     const inspectPack = dependencies.inventoryPack ?? inventoryPack;
+    // `list` reports the same packs as `status` and `doctor`, so it resolves the
+    // same config-aware provider surface. Without it, `list` reported user
+    // agents as unmaterialized that an active Codex or Cursor adapter supplies.
+    const providerSurface = await resolvePackProviderSurface({
+        scopeRoots: roots,
+        ...(dependencies.providerContext
+            ? { dependencies: dependencies.providerContext }
+            : {}),
+    });
     const inspected = await Promise.all(PACK_MANIFEST.map(({ name }) => inspectPack({
         pack: name,
         assetsRoot,
         projectRoot: roots.project,
         userRoot: roots.user,
-    }).then((canonical) => ({
-        canonical,
-        evidence: projectRenderablePackEvidence(canonical, packRoots),
-    }), (error) => ({
+        ...(roots.user
+            ? {
+                userManagedRoleMaterialization: providerSurface.userAgentCoverage !== 'none',
+            }
+            : {}),
+    }).then((raw) => {
+        const canonical = applyUserAgentCoverage(raw, providerSurface.userAgentCoverage);
+        return {
+            canonical,
+            evidence: projectRenderablePackEvidence(canonical, packRoots, providerSurface.contexts),
+        };
+    }, (error) => ({
         canonical: null,
         evidence: unavailablePackEvidence({
             pack: name,

package/dist/commands/tools/remove/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAW1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAM7B,MAAM,gBAAgB,CAAC;AAqExB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAkOT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAkB1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAM7B,MAAM,gBAAgB,CAAC;AAkDxB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAmPT"}

package/dist/commands/tools/remove/index.js

@@ -1,11 +1,15 @@
-import { execFile } from 'node:child_process';
 import { lstat, rm } from 'node:fs/promises';
 import { relative } from 'node:path';
 import { buildCommandContext } from '../../../app/command-context.js';
 import { withScopeOption } from '../../shared/scope-option.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../../shared/shared.utils.js';
 import { autoSync, } from '../../tools/shared/auto-sync.js';
+import { inProcessSyncDependencies } from '../../tools/shared/in-process-sync.js';
 import { inventoryScopedPack } from '../../tools/shared/pack-inventory.js';
+import { providerSyncOutcomeFromAutoSync, } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { withLifecycleProviderEvidence } from '../../tools/shared/pack-provider-evidence.js';
+import { resolveProviderScopeContexts } from '../../tools/shared/provider-context.js';
+import { applySyncEvidence } from '../../tools/shared/provider-reachability.js';
 import { scanTools } from '../../tools/shared/scan-tools.js';
 import { hasScopedPackOwnershipEvidence, writeScopedPackIntent, } from '../../tools/shared/scoped-pack-intent.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
@@ -45,28 +49,7 @@ const defaultDependencies = {
     inventoryScopedPack,
     writeScopedPackIntent,
 };
-const defaultSyncDependencies = {
-    runSync: async ({ scope, cwd, removedCanonicalPaths }) => {
-        const args = [
-            ...process.execArgv,
-            process.argv[1],
-            'sync',
-            '--scope',
-            scope,
-        ];
-        for (const canonicalPath of removedCanonicalPaths ?? []) {
-            args.push('--remove-canonical', canonicalPath);
-        }
-        await new Promise((resolve, reject) => {
-            execFile(process.execPath, args, { cwd }, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-};
+const defaultSyncDependencies = inProcessSyncDependencies;
 const VALID_PACKS = [
     'core',
     'ideas',
@@ -164,7 +147,12 @@ export function createToolsRemoveCommand(dependencies = defaultDependencies, syn
                             }));
                         }
                     }
-                    result.lifecycle = removalLifecycleOutcomes(selectedPacks(target), scopes, result.packOutcomes, false, finalInventories);
+                    result.lifecycle = removalLifecycleOutcomes(selectedPacks(target), scopes, result.packOutcomes, false, finalInventories, await resolveProviderScopeContexts({
+                        scopeRoots: Object.fromEntries(await Promise.all(scopes.map(async (scope) => [
+                            scope,
+                            await dependencies.resolveScopeRoot(scope, context.cwd, context.home),
+                        ]))),
+                    }));
                 }
             }
             catch (error) {
@@ -249,27 +237,32 @@ function finalizeRemovalLifecycle(lifecycle, syncResults) {
         return lifecycle;
     return lifecycle.map((outcome) => {
         const relevant = syncResults.filter(({ scopes }) => scopes.some((scope) => outcome.selection.targetScopes.includes(scope)));
-        if (relevant.length === 0 || relevant.every(({ synced }) => synced)) {
-            return relevant.length === 0
-                ? outcome
-                : {
-                    ...outcome,
-                    sync: {
-                        scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
-                        status: 'complete',
-                        providers: [],
-                    },
-                };
+        const merged = {
+            synced: relevant.every(({ synced }) => synced),
+            scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
+            error: relevant.find((result) => result.error)?.error ?? null,
+            evidence: relevant.flatMap(({ evidence }) => evidence),
+        };
+        const providers = applySyncEvidence(outcome.sync.providers, {
+            syncRan: merged.evidence.some(({ ran }) => ran),
+            syncOperationResults: merged.evidence.flatMap(({ operationResults }) => operationResults),
+            extensionResults: merged.evidence.flatMap(({ extensionResults }) => extensionResults),
+        });
+        if (relevant.length === 0)
+            return outcome;
+        // The status comes from the shared severity-matrix rule rather than from
+        // `synced` alone: a sync that returned successfully can still carry an
+        // observed provider materialization failure, which is a `partial`.
+        const sync = providerSyncOutcomeFromAutoSync(merged, providers);
+        const finalEvidence = withLifecycleProviderEvidence(outcome.finalEvidence, providers);
+        if (sync.status === 'complete') {
+            return { ...outcome, sync, finalEvidence };
         }
-        const error = relevant.find((result) => result.error)?.error;
+        const error = merged.error ?? undefined;
         return {
             ...outcome,
-            sync: {
-                scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
-                status: 'failed',
-                providers: [],
-                ...(error ? { error } : {}),
-            },
+            sync,
+            finalEvidence,
             status: 'partial',
             recovery: [
                 ...outcome.recovery,

package/dist/commands/tools/remove/remove-tools.d.ts

@@ -1,8 +1,9 @@
 import { type InventoryScopedPackInput, type ScopedPackInventory } from '../../tools/shared/pack-inventory.js';
 import { type PackLifecycleRequest, type PackLifecycleResult } from '../../tools/shared/pack-lifecycle.js';
-import type { PackLifecycleOutcome } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { type PackLifecycleOutcome } from '../../tools/shared/pack-lifecycle-outcome.js';
 import type { ScanToolsOptions } from '../../tools/shared/scan-tools.js';
 import type { PackName, ToolInfo } from '../../tools/shared/types.js';
+import type { ProviderScopeContext } from '../../../providers/shared/registry.js';
 import type { ConcreteScope } from '../../../shared/types.js';
 export type RemoveTarget = {
     kind: 'name';
@@ -72,7 +73,7 @@ export declare function selectedPacks(target: Exclude<RemoveTarget, {
     kind: 'name';
 }>): PackName[];
 export declare function removeTools(target: RemoveTarget, scopes: ConcreteScope[], cwd: string, home: string, dryRun: boolean, deps: RemoveToolsDependencies): Promise<RemoveResult>;
-export declare function removalLifecycleOutcomes(packs: readonly PackName[], scopes: readonly ConcreteScope[], outcomes: readonly PackRemovalOutcome[], dryRun: boolean, finalInventories: readonly ScopedPackInventory[]): PackLifecycleOutcome[];
+export declare function removalLifecycleOutcomes(packs: readonly PackName[], scopes: readonly ConcreteScope[], outcomes: readonly PackRemovalOutcome[], dryRun: boolean, finalInventories: readonly ScopedPackInventory[], providerContexts?: readonly ProviderScopeContext[]): PackLifecycleOutcome[];
 export declare function failedRemovalLifecycleOutcomes(target: Exclude<RemoveTarget, {
     kind: 'name';
 }>, scopes: readonly ConcreteScope[], error: unknown): PackLifecycleOutcome[];

package/dist/commands/tools/remove/remove-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/remove-tools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"remove-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/remove-tools.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACzB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,+CAA+C,CAAC;AAIvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAEV,QAAQ,EACR,QAAQ,EACT,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,wBAAwB,EAAE,CACxB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,cAAc,CAAC,EAAE,CACf,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,KAC3B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACpC,mBAAmB,CAAC,EAAE,CACpB,KAAK,EAAE,wBAAwB,KAC5B,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClC,qBAAqB,CAAC,EAAE,CAAC,KAAK,EAAE;QAC9B,IAAI,EAAE,QAAQ,CAAC;QACf,KAAK,EAAE,aAAa,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;KAClB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;IAC7D,iBAAiB,EAAE,KAAK,CAAC;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,aAAa,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH,YAAY,EAAE,kBAAkB,EAAE,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACpC;AA6DD,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,cAI5E;AA8ID,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2NvB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,MAAM,EAAE,OAAO,EACf,gBAAgB,EAAE,SAAS,mBAAmB,EAAE,EAChD,gBAAgB,GAAE,SAAS,oBAAoB,EAAO,GACrD,oBAAoB,EAAE,CA2ExB;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAC/C,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,OAAO,GACb,oBAAoB,EAAE,CAsBxB;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAC/C,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,KAAK,EAAE,cAAc,GAAG,iBAAiB,EACzC,UAAU,EAAE,QAAQ,EACpB,WAAW,EAAE,aAAa,EAC1B,KAAK,EAAE,OAAO,GACb,oBAAoB,EAAE,CAwCxB"}

package/dist/commands/tools/remove/remove-tools.js

@@ -2,7 +2,9 @@ import { join } from 'node:path';
 import { packScopeFactsFromInventory, projectPackEvidence, } from '../../tools/shared/pack-evidence.js';
 import { hasScopedPackPlacementEvidence, } from '../../tools/shared/pack-inventory.js';
 import {} from '../../tools/shared/pack-lifecycle.js';
+import { notRunProviderSyncOutcome, } from '../../tools/shared/pack-lifecycle-outcome.js';
 import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
+import { lifecycleProviderEvidence } from '../../tools/shared/pack-provider-evidence.js';
 import { resolveSharedOwnerRetentions } from '../../tools/shared/pack-reconcile.js';
 import { resolveManagedScopeRoots, validateManagedPath, } from '../../../fs/paths.js';
 function matchesTarget(tool, target) {
@@ -286,7 +288,7 @@ export async function removeTools(target, scopes, cwd, home, dryRun, deps) {
         lifecycle: removalLifecycleOutcomes(selectedPacks(target), scopes, packOutcomes, dryRun, finalInventories),
     };
 }
-export function removalLifecycleOutcomes(packs, scopes, outcomes, dryRun, finalInventories) {
+export function removalLifecycleOutcomes(packs, scopes, outcomes, dryRun, finalInventories, providerContexts = []) {
     if (finalInventories.length === 0)
         return [];
     return packs.map((pack) => {
@@ -333,7 +335,15 @@ export function removalLifecycleOutcomes(packs, scopes, outcomes, dryRun, finalI
                 status: removed && !dryRun ? 'applied' : 'unchanged',
                 results: [],
             },
-            sync: { scopes: [], status: 'not-run', providers: [] },
+            // After a completed removal the pack has no realized assets, so the
+            // mapper legitimately produces no rows; a retained or dry-run pack still
+            // reports its providers.
+            sync: notRunProviderSyncOutcome(lifecycleProviderEvidence({
+                pack,
+                scopedInventories: packInventories,
+                providerContexts,
+                scopes,
+            }), 'Auto-sync has not run for this operation'),
             finalEvidence,
             status: verified ? 'complete' : inventoryVerified ? 'partial' : 'failed',
             recovery,
@@ -353,7 +363,7 @@ export function failedRemovalLifecycleOutcomes(target, scopes, error) {
             targetScopes: scopes,
         },
         canonical: { status: 'failed', results: [] },
-        sync: { scopes: [], status: 'not-run', providers: [] },
+        sync: notRunProviderSyncOutcome([], 'Canonical removal failed before auto-sync'),
         finalEvidence: null,
         status: 'failed',
         recovery: [{ code: 'canonical-apply-failed', message }],
@@ -383,7 +393,7 @@ export function failedPostRemovalLifecycleOutcomes(target, scopes, outcomes, sta
                 status: canonicalApplied ? 'applied' : 'unchanged',
                 results: [],
             },
-            sync: { scopes: [], status: 'not-run', providers: [] },
+            sync: notRunProviderSyncOutcome([], `Auto-sync did not run because the ${stageLabel}`),
             finalEvidence: null,
             status: 'failed',
             recovery: scopes.map((scope) => ({

package/dist/commands/tools/shared/auto-sync.d.ts

@@ -1,18 +1,29 @@
 import type { ConcreteScope } from '../../../shared/types.js';
 import type { CliLogger } from '../../../ui/logger.js';
+import { type SyncRunEvidence } from './sync-evidence.js';
 export interface AutoSyncDependencies {
+    /**
+     * Runs one scope's sync and returns its normalized evidence.
+     *
+     * The production implementation runs sync in-process and consumes the
+     * evidence object directly; it does not spawn `oat sync --json` and parse
+     * stdout. Returning `void` is still accepted so an injected test double or a
+     * caller that only needs the success/failure signal stays valid.
+     */
     runSync: (options: {
         scope: ConcreteScope;
         cwd: string;
         home: string;
         installedCanonicalPaths?: string[];
         removedCanonicalPaths?: string[];
-    }) => Promise<void>;
+    }) => Promise<SyncRunEvidence | void>;
 }
 export interface AutoSyncResult {
     synced: boolean;
     scopes: ConcreteScope[];
     error: string | null;
+    /** One entry per scope the run reached, in the order it ran them. */
+    evidence: readonly SyncRunEvidence[];
 }
 export interface AutoSyncOptions {
     installedCanonicalPaths?: string[];

package/dist/commands/tools/shared/auto-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/auto-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,CAAC,OAAO,EAAE;QACjB,KAAK,EAAE,aAAa,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;QACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;KAClC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAsBzB"}
+{"version":3,"file":"auto-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/auto-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE7E,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE;QACjB,KAAK,EAAE,aAAa,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;QACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;KAClC,KAAK,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,qEAAqE;IACrE,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC9B,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAwCzB"}

package/dist/commands/tools/shared/auto-sync.js

@@ -1,23 +1,39 @@
+import { emptySyncRunEvidence } from './sync-evidence.js';
 export async function autoSync(scopes, cwd, home, logger, dependencies, options) {
     if (scopes.length === 0) {
-        return { synced: false, scopes: [], error: null };
+        return { synced: false, scopes: [], error: null, evidence: [] };
     }
+    const evidence = [];
     try {
         for (const scope of scopes) {
-            await dependencies.runSync({
+            const result = await dependencies.runSync({
                 scope,
                 cwd,
                 home,
                 installedCanonicalPaths: options?.installedCanonicalPaths,
                 removedCanonicalPaths: options?.removedCanonicalPaths,
             });
+            evidence.push(result ?? { ...emptySyncRunEvidence(scope), ran: true });
+        }
+        // A sync can fail without throwing: `runSyncApply` reports failed
+        // operations and returns normally. Treating that as success is what let a
+        // failed sync print `Auto-sync completed.` and exit 0. The evidence is
+        // kept either way so the failed provider rows survive.
+        const failedOperations = evidence.reduce((total, run) => total + run.failedOperations, 0);
+        if (failedOperations > 0) {
+            const message = `oat sync reported ${failedOperations} failed operation(s)`;
+            logger.warn(`Auto-sync failed: ${message}`);
+            return { synced: false, scopes, error: message, evidence };
         }
         logger.info('Auto-sync completed.');
-        return { synced: true, scopes, error: null };
+        return { synced: true, scopes, error: null, evidence };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         logger.warn(`Auto-sync failed: ${message}`);
-        return { synced: false, scopes, error: message };
+        // Evidence collected before the failure is preserved: a two-scope run that
+        // failed on the second scope still reached the first, and discarding that
+        // would report a reachable provider as unknown.
+        return { synced: false, scopes, error: message, evidence };
     }
 }

package/dist/commands/tools/shared/format-pack-inventory.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderScopeContext } from '../../../providers/shared/registry.js';
 import type { ConcreteScope } from '../../../shared/types.js';
 import { type PackEvidenceDiagnostic, type ToolPackEvidence } from './pack-evidence.js';
 import type { PackInventory } from './pack-inventory.js';
@@ -15,7 +16,17 @@ export declare function unavailablePackEvidence(input: {
     reason: string;
     roots?: PackPathRoots;
 }): ToolPackEvidence;
-export declare function projectRenderablePackEvidence(canonical: PackInventory, roots: PackPathRoots): ToolPackEvidence;
+/**
+ * Projects a renderable pack evidence item.
+ *
+ * `providerContexts` is the config-aware provider context per scope. When it
+ * is supplied, provider reachability is mapped from the registry and the
+ * resulting `provider-materialization-missing` diagnostics name the provider.
+ * When it is absent — a surface that could not resolve a sync config — the
+ * unattributed inventory-derived diagnostic is emitted instead, so the
+ * warning is never silently lost.
+ */
+export declare function projectRenderablePackEvidence(canonical: PackInventory, roots: PackPathRoots, providerContexts?: readonly ProviderScopeContext[]): ToolPackEvidence;
 export declare function packEvidenceBlock(items: readonly ToolPackEvidence[]): PackEvidenceBlockV1;
 export declare function formatPackEvidenceDetails(evidence: ToolPackEvidence, indent?: string): string[];
 export declare function formatPackInventoryDetails(inventory: PackInventory, indent?: string): string[];

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

@@ -1 +1 @@
-{"version":3,"file":"format-pack-inventory.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/format-pack-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;IACnC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,sBAAsB,EAAE,CAAC;CAChD;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,GAAG,gBAAgB,CAoBnB;AA4CD,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,aAAa,GACnB,gBAAgB,CAiClB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,gBAAgB,EAAE,GACjC,mBAAmB,CAQrB;AAUD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,SAAO,GACZ,MAAM,EAAE,CAuBV;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,aAAa,EACxB,MAAM,SAAO,GACZ,MAAM,EAAE,CAuBV"}
+{"version":3,"file":"format-pack-inventory.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/format-pack-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;IACnC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,sBAAsB,EAAE,CAAC;CAChD;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,GAAG,gBAAgB,CAoBnB;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,aAAa,EACpB,gBAAgB,CAAC,EAAE,SAAS,oBAAoB,EAAE,GACjD,gBAAgB,CAyDlB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,gBAAgB,EAAE,GACjC,mBAAmB,CAerB;AAUD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,SAAO,GACZ,MAAM,EAAE,CAiCV;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,aAAa,EACxB,MAAM,SAAO,GACZ,MAAM,EAAE,CAuBV"}

package/dist/commands/tools/shared/format-pack-inventory.js

@@ -1,5 +1,6 @@
 import { packScopeFactsFromInventory, projectPackEvidence, unavailablePackScopeFacts, } from './pack-evidence.js';
 import { formatPackPath } from './pack-paths.js';
+import { packProviderEvidence } from './pack-provider-evidence.js';
 export function unavailablePackEvidence(input) {
     const reason = redactPackText(input.reason, input.roots ?? {});
     const facts = input.scopes.map((scope) => unavailablePackScopeFacts({
@@ -56,14 +57,42 @@ function redactPackInventory(inventory, roots) {
         })),
     };
 }
-export function projectRenderablePackEvidence(canonical, roots) {
+/**
+ * Projects a renderable pack evidence item.
+ *
+ * `providerContexts` is the config-aware provider context per scope. When it
+ * is supplied, provider reachability is mapped from the registry and the
+ * resulting `provider-materialization-missing` diagnostics name the provider.
+ * When it is absent — a surface that could not resolve a sync config — the
+ * unattributed inventory-derived diagnostic is emitted instead, so the
+ * warning is never silently lost.
+ */
+export function projectRenderablePackEvidence(canonical, roots, providerContexts) {
     const redacted = redactPackInventory(canonical, roots);
+    const providers = providerContexts && providerContexts.length > 0
+        ? packProviderEvidence({
+            pack: redacted.pack,
+            scopedInventories: redacted.scopes,
+            providerContexts,
+            mode: 'inventory',
+        })
+        : [];
     const evidence = projectPackEvidence({
         canonical: redacted,
         scopes: redacted.scopes.map(packScopeFactsFromInventory),
+        providers,
+        providerMode: 'inventory',
     });
-    const providerDiagnostics = redacted.scopes.flatMap((scoped) => scoped.diagnostics
-        .filter(({ code }) => code === 'user-agent-unmaterialized')
+    // Assets a provider row already reports as missing are covered by the
+    // named diagnostic. Anything left over has no responsible active provider,
+    // so the unattributed pack-level warning is still the only report of it and
+    // must not be dropped just because provider rows exist.
+    const attributedAssets = new Set(providers
+        .filter(({ materialization }) => materialization.state === 'missing')
+        .flatMap(({ assets }) => assets));
+    const legacyDiagnostics = redacted.scopes.flatMap((scoped) => scoped.diagnostics
+        .filter(({ code, paths }) => code === 'user-agent-unmaterialized' &&
+        paths.some((path) => !attributedAssets.has(path)))
         .map((diagnostic) => ({
         code: 'provider-materialization-missing',
         severity: 'warning',
@@ -83,14 +112,19 @@ export function projectRenderablePackEvidence(canonical, roots) {
     })));
     return {
         ...evidence,
-        diagnostics: [...evidence.diagnostics, ...providerDiagnostics],
+        diagnostics: [...evidence.diagnostics, ...legacyDiagnostics],
     };
 }
 export function packEvidenceBlock(items) {
     const diagnostics = items.flatMap(({ diagnostics: values }) => values);
+    // Severity, never the diagnostic count, decides the block status. `info`
+    // rows (an inactive provider, an unsupported content kind, a host that
+    // needs a catalog refresh) are reportable facts about a healthy install,
+    // so counting them would turn every correctly configured host `partial`.
+    const actionable = diagnostics.some(({ severity }) => severity === 'warning' || severity === 'error');
     return {
         schemaVersion: 1,
-        status: diagnostics.length > 0 ? 'partial' : 'ok',
+        status: actionable ? 'partial' : 'ok',
         items,
         diagnostics,
     };
@@ -108,8 +142,16 @@ export function formatPackEvidenceDetails(evidence, indent = '  ') {
             lines.push(`${indent}  Inventory: ${scoped.inventory.reason}`);
         }
     }
+    // Human output names the provider; the structured evidence stays in JSON.
+    // The materialization detail is rendered alongside the state because
+    // `not-applicable` alone collapses two different situations: a provider
+    // that is inactive or cannot project this content, and an active provider
+    // on a read-only surface that simply observed no sync.
+    for (const provider of evidence.providers) {
+        lines.push(`${indent}${provider.provider} [${provider.scope} ${provider.contentKind}]: ${provider.activation.state}; capability=${provider.capability.support}; projection=${provider.projection.state}; materialization=${provider.materialization.state} (${provider.materialization.detail}); visibility=${provider.visibility.state}`);
+    }
     for (const diagnostic of evidence.diagnostics) {
-        lines.push(`${indent}${diagnostic.code}: ${diagnostic.detail}`, ...(diagnostic.affectedAssets.length > 0
+        lines.push(`${indent}${diagnostic.code}${diagnostic.provider ? ` [${diagnostic.provider}]` : ''}: ${diagnostic.detail}`, ...(diagnostic.affectedAssets.length > 0
             ? [`${indent}  Affected: ${diagnostic.affectedAssets.join(', ')}`]
             : []), ...diagnostic.recovery.map(({ command, message }) => `${indent}  Fix: ${message}${command ? ` (${command})` : ''}`));
     }

package/dist/commands/tools/shared/in-process-sync.d.ts

@@ -0,0 +1,11 @@
+import type { AutoSyncDependencies } from './auto-sync.js';
+/**
+ * The production auto-sync seam for every pack lifecycle command.
+ *
+ * Runs sync in-process and consumes the evidence object the sync run already
+ * builds, rather than spawning `oat sync --json` and parsing stdout. The
+ * subprocess it replaces discarded that evidence entirely, which is why every
+ * lifecycle outcome carried an empty provider array.
+ */
+export declare const inProcessSyncDependencies: AutoSyncDependencies;
+//# sourceMappingURL=in-process-sync.d.ts.map

package/dist/commands/tools/shared/in-process-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-process-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/in-process-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAyBxD;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,EAAE,oBAqDvC,CAAC"}

package/dist/commands/tools/shared/in-process-sync.js

@@ -0,0 +1,79 @@
+import { runSyncInProcess } from '../../sync/index.js';
+import { normalizeSyncEvidence } from './sync-evidence.js';
+/**
+ * Silent logger that captures the sync run's JSON payload.
+ *
+ * Auto-sync has never surfaced the child sync's output — the previous
+ * subprocess implementation captured and discarded its stdout — so keeping
+ * every channel silent preserves the lifecycle command's human output exactly
+ * while making the evidence object available to the caller.
+ */
+function capturingSyncLogger(sink) {
+    const noop = () => { };
+    return {
+        debug: noop,
+        info: noop,
+        warn: noop,
+        error: noop,
+        success: noop,
+        json(payload) {
+            sink.payload = payload;
+        },
+    };
+}
+/**
+ * The production auto-sync seam for every pack lifecycle command.
+ *
+ * Runs sync in-process and consumes the evidence object the sync run already
+ * builds, rather than spawning `oat sync --json` and parsing stdout. The
+ * subprocess it replaces discarded that evidence entirely, which is why every
+ * lifecycle outcome carried an empty provider array.
+ */
+export const inProcessSyncDependencies = {
+    runSync: async ({ scope, cwd, home, installedCanonicalPaths, removedCanonicalPaths, }) => {
+        const sink = { payload: null };
+        const context = {
+            scope,
+            dryRun: false,
+            verbose: false,
+            json: true,
+            cwd,
+            home,
+            interactive: false,
+            logger: capturingSyncLogger(sink),
+        };
+        // `runSyncApply` assigns `process.exitCode` for its own run. In a
+        // subprocess that was the child's exit status and never reached the
+        // parent command; in-process it would overwrite the parent's own result,
+        // including resetting a failure to 0, so the parent's value is restored.
+        //
+        // That exit code is also the only signal sync gives for a run that failed
+        // without throwing: `runSyncApply` sets 1 when operations failed and
+        // returns normally. The subprocess this replaces surfaced that as an
+        // `execFile` rejection, which auto-sync recorded as a failed sync. Reading
+        // it before restoring keeps that contract instead of reporting a failed
+        // sync as `Auto-sync completed.` with exit 0.
+        const priorExitCode = process.exitCode;
+        let syncExitCode;
+        try {
+            await runSyncInProcess(context, {
+                ...(installedCanonicalPaths ? { installedCanonicalPaths } : {}),
+                ...(removedCanonicalPaths ? { removedCanonicalPaths } : {}),
+            });
+            syncExitCode = process.exitCode;
+        }
+        finally {
+            process.exitCode = priorExitCode;
+        }
+        const evidence = normalizeSyncEvidence(scope, sink.payload);
+        // The failure is reported through the evidence rather than by throwing:
+        // a throw would discard the very rows that describe which provider
+        // failed, and those rows are what emit `provider-materialization-failed`.
+        // A non-zero exit with no counted operation (a rejected collection is a
+        // failure but not a planned operation) still records one.
+        const exitedNonZero = typeof syncExitCode === 'number' && syncExitCode !== 0;
+        return exitedNonZero && evidence.failedOperations === 0
+            ? { ...evidence, failedOperations: 1 }
+            : evidence;
+    },
+};